From 3eb313ef3cf3c7a0c2634ee1d3b1361046aaaaef Mon Sep 17 00:00:00 2001 From: navid Date: Fri, 21 Nov 2008 03:01:40 +0000 Subject: [PATCH] *** empty log message *** --- .../TransactionalIOSrc/Utilities/Range.java | 108 ++ .../TransactionalIOSrc/benchmarks/Main.java | 152 ++ .../benchmarks/MainforLocks.java | 142 ++ .../benchmarks/StatisticsWrapper.java | 17 + .../benchmarks/benchmark.java | 270 +++ .../benchmarks/customhandler.java | 62 + .../benchmarks/lockthread1.java | 86 + .../benchmarks/thread1.java | 489 +++++ .../benchmarks/thread2.java | 38 + .../benchmarks/thread3.java | 55 + .../benchmarks/thread4.java | 53 + .../core/BlockDataStructure.java | 107 ++ .../TransactionalIOSrc/core/CustomLock.java | 62 + .../TransactionalIOSrc/core/CustomThread.java | 113 ++ .../TransactionalIOSrc/core/Defaults.java | 73 + .../core/ExtendedTransaction.java | 971 ++++++++++ .../core/FileBlockManager.java | 34 + .../core/GlobalINodeState.java | 118 ++ .../TransactionalIOSrc/core/GlobalOffset.java | 52 + .../TransactionalIOSrc/core/HelloWorld.c | 9 + .../TransactionalIOSrc/core/HelloWorld.h | 19 + .../TransactionalIOSrc/core/INode.java | 61 + .../TransactionalIOSrc/core/IOlib | Bin 0 -> 24696 bytes .../TransactionalIOSrc/core/IOlib.so | Bin 0 -> 24696 bytes .../core/ManagerRepository.java | 36 + .../TransactionalIOSrc/core/NativeFunctions.c | 30 + .../TransactionalIOSrc/core/NativeFunctions.h | 19 + .../TransactionalIOSrc/core/NativeFunctions.o | Bin 0 -> 23672 bytes .../core/TransactionLocalFileAttributes.java | 77 + .../core/TransactionalFile.java | 1592 +++++++++++++++++ .../core/TransactionalFileWrapperFactory.java | 67 + .../TransactionalIOSrc/core/Wrapper.java | 115 ++ .../core/WriteOperations.java | 82 + .../exceptions/PanicException.java | 69 + .../interfaces/BlockAccessModesEnum.java | 14 + .../interfaces/ContentionManager.java | 36 + .../interfaces/FileAccessModesEum.java | 17 + .../interfaces/OffsetDependency.java | 15 + .../interfaces/TransactionStatu.java | 23 + .../interfaces/TransactionalProgram.java | 15 + 40 files changed, 5298 insertions(+) create mode 100644 Robust/Transactions/TransactionalIOSrc/Utilities/Range.java create mode 100644 Robust/Transactions/TransactionalIOSrc/benchmarks/Main.java create mode 100644 Robust/Transactions/TransactionalIOSrc/benchmarks/MainforLocks.java create mode 100644 Robust/Transactions/TransactionalIOSrc/benchmarks/StatisticsWrapper.java create mode 100644 Robust/Transactions/TransactionalIOSrc/benchmarks/benchmark.java create mode 100644 Robust/Transactions/TransactionalIOSrc/benchmarks/customhandler.java create mode 100644 Robust/Transactions/TransactionalIOSrc/benchmarks/lockthread1.java create mode 100644 Robust/Transactions/TransactionalIOSrc/benchmarks/thread1.java create mode 100644 Robust/Transactions/TransactionalIOSrc/benchmarks/thread2.java create mode 100644 Robust/Transactions/TransactionalIOSrc/benchmarks/thread3.java create mode 100644 Robust/Transactions/TransactionalIOSrc/benchmarks/thread4.java create mode 100644 Robust/Transactions/TransactionalIOSrc/core/BlockDataStructure.java create mode 100644 Robust/Transactions/TransactionalIOSrc/core/CustomLock.java create mode 100644 Robust/Transactions/TransactionalIOSrc/core/CustomThread.java create mode 100644 Robust/Transactions/TransactionalIOSrc/core/Defaults.java create mode 100644 Robust/Transactions/TransactionalIOSrc/core/ExtendedTransaction.java create mode 100644 Robust/Transactions/TransactionalIOSrc/core/FileBlockManager.java create mode 100644 Robust/Transactions/TransactionalIOSrc/core/GlobalINodeState.java create mode 100644 Robust/Transactions/TransactionalIOSrc/core/GlobalOffset.java create mode 100644 Robust/Transactions/TransactionalIOSrc/core/HelloWorld.c create mode 100644 Robust/Transactions/TransactionalIOSrc/core/HelloWorld.h create mode 100644 Robust/Transactions/TransactionalIOSrc/core/INode.java create mode 100644 Robust/Transactions/TransactionalIOSrc/core/IOlib create mode 100644 Robust/Transactions/TransactionalIOSrc/core/IOlib.so create mode 100644 Robust/Transactions/TransactionalIOSrc/core/ManagerRepository.java create mode 100644 Robust/Transactions/TransactionalIOSrc/core/NativeFunctions.c create mode 100644 Robust/Transactions/TransactionalIOSrc/core/NativeFunctions.h create mode 100644 Robust/Transactions/TransactionalIOSrc/core/NativeFunctions.o create mode 100644 Robust/Transactions/TransactionalIOSrc/core/TransactionLocalFileAttributes.java create mode 100644 Robust/Transactions/TransactionalIOSrc/core/TransactionalFile.java create mode 100644 Robust/Transactions/TransactionalIOSrc/core/TransactionalFileWrapperFactory.java create mode 100644 Robust/Transactions/TransactionalIOSrc/core/Wrapper.java create mode 100644 Robust/Transactions/TransactionalIOSrc/core/WriteOperations.java create mode 100644 Robust/Transactions/TransactionalIOSrc/exceptions/PanicException.java create mode 100644 Robust/Transactions/TransactionalIOSrc/interfaces/BlockAccessModesEnum.java create mode 100644 Robust/Transactions/TransactionalIOSrc/interfaces/ContentionManager.java create mode 100644 Robust/Transactions/TransactionalIOSrc/interfaces/FileAccessModesEum.java create mode 100644 Robust/Transactions/TransactionalIOSrc/interfaces/OffsetDependency.java create mode 100644 Robust/Transactions/TransactionalIOSrc/interfaces/TransactionStatu.java create mode 100644 Robust/Transactions/TransactionalIOSrc/interfaces/TransactionalProgram.java diff --git a/Robust/Transactions/TransactionalIOSrc/Utilities/Range.java b/Robust/Transactions/TransactionalIOSrc/Utilities/Range.java new file mode 100644 index 00000000..0de34e3d --- /dev/null +++ b/Robust/Transactions/TransactionalIOSrc/Utilities/Range.java @@ -0,0 +1,108 @@ +/* + * To change this template, choose Tools | Templates + * and open the template in the editor. + */ +package TransactionalIO.Utilities; + + +/** + * + * @author navid + */ +public class Range implements Comparable { + + private long start; + private long end; + + public Range() { + } + + public Range(long start, long end) { + this.start = start; + this.end = end; + } + + public long getEnd() { + return end; + } + + public void setEnd(long end) { + this.end = end; + } + + public long getStart() { + return start; + } + + public void setStart(long start) { + this.start = start; + } + + public Range intersection(Range secondrange) { + if ((secondrange.start <= this.start) && (this.start <= secondrange.end)) { + return new Range(this.start, Math.min(this.end, secondrange.end)); + } else if ((secondrange.start <= this.end) && (this.end <= secondrange.end)) { + return new Range(Math.max(this.start, secondrange.start), this.end); + } else if ((this.start <= secondrange.start) && (secondrange.end <= this.end)) { + return new Range(secondrange.start, secondrange.end); + } else { + return null; + } + } + + public boolean hasIntersection(Range secondrange) { + if ((secondrange.start <= this.start) && (this.start <= secondrange.end)) { + return true; + } else if ((secondrange.start <= this.end) && (this.end <= secondrange.end)) { + return true; + } else if ((this.start <= secondrange.start) && (secondrange.end <= this.end)) { + return true; + } else { + return false; + } + } + + + public boolean includes(Range secondrange) { + if (this.start <= secondrange.start && secondrange.end <= this.end) { + return true; + } else { + return false; + } + } + + public Range[] minus(Range[] intersectedranges, int size) { + Range[] tmp = new Range[size + 1]; + + int counter = 0; + if (this.start < intersectedranges[0].start) { + tmp[counter] = new Range(this.start, intersectedranges[0].start); + counter++; + } + for (int i = 1; i < size; i++) { + tmp[counter] = new Range(intersectedranges[i - 1].end, intersectedranges[i].start); + counter++; + } + if (this.end > intersectedranges[size - 1].end) { + tmp[counter] = new Range(intersectedranges[size - 1].end, this.end); + counter++; + } + Range[] result = new Range[counter]; + for (int i = 0; i < counter; i++) { + result[i] = tmp[i]; + } + return result; + } + + public int compareTo(Object arg0) { + + Range tmp = (Range) arg0; + if (this.start < tmp.start) { + return -1; + } else if (this.start == tmp.start) { + return 0; + } else { + return 1; + } + } +} diff --git a/Robust/Transactions/TransactionalIOSrc/benchmarks/Main.java b/Robust/Transactions/TransactionalIOSrc/benchmarks/Main.java new file mode 100644 index 00000000..7797e908 --- /dev/null +++ b/Robust/Transactions/TransactionalIOSrc/benchmarks/Main.java @@ -0,0 +1,152 @@ +/* + * To change this template, choose Tools | Templates + * and open the template in the editor. + */ + +package TransactionalIO.benchmarks; + +import TransactionalIO.core.CustomThread; +import TransactionalIO.core.ExtendedTransaction; +import TransactionalIO.core.TransactionalFile; +import java.io.File; +import java.util.Iterator; +import java.util.TreeMap; +import java.util.logging.Level; +import java.util.logging.Logger; + +/** + * + * @author navid + */ +public class Main { + + public static void main(String args[]){ + try { + // benchmark.init(); + + + // for (int i=0; i<100; i++){ + benchmark.init(); + //System.out.println( + long starttime = System.nanoTime(); + /* thread1 tr1 = new thread1(); + thread2 tr2 = new thread2(); + thread3 tr3 = new thread3(); + thread4 tr4 = new thread4();*/ + /*TransactionalIO tr2 = new TransactionalIO(); + TransactionalIO tr3 = new TransactionalIO(); + CustomThread ct1 = new CustomThread(tr1); + CustomThread ct2 = new CustomThread(tr2);*/ + + /* CustomThread ct1 = new CustomThread(new thread1('a', new TransactionalFile("/home/navid/output.text", "rw"))); + CustomThread ct2 = new CustomThread(new thread1('b', new TransactionalFile("/home/navid/output.text", "rw"))); + CustomThread ct3 = new CustomThread(new thread1('c', new TransactionalFile("/home/navid/output.text", "rw"))); + CustomThread ct4= new CustomThread(new thread1('d', new TransactionalFile("/home/navid/output.text", "rw"))); + CustomThread ct5 = new CustomThread(new thread1('e', new TransactionalFile("/home/navid/output.text", "rw"))); + CustomThread ct6 = new CustomThread(new thread1('f', new TransactionalFile("/home/navid/output.text", "rw"))); + CustomThread ct7 = new CustomThread(new thread1('g', new TransactionalFile("/home/navid/output.text", "rw"))); + CustomThread ct8 = new CustomThread(new thread1('h', new TransactionalFile("/home/navid/output.text", "rw"))); + CustomThread ct9 = new CustomThread(new thread1('i',new TransactionalFile("/home/navid/output.text", "rw"))); + CustomThread ct10 = new CustomThread(new thread1('j', new TransactionalFile("/home/navid/output.text", "rw"))); + CustomThread ct11 = new CustomThread(new thread1('k', new TransactionalFile("/home/navid/output.text", "rw"))); + CustomThread ct12 = new CustomThread(new thread1('l', new TransactionalFile("/home/navid/output.text", "rw"))); + CustomThread ct13 = new CustomThread(new thread1('m', new TransactionalFile("/home/navid/output.text", "rw"))); + CustomThread ct14 = new CustomThread(new thread1('n', new TransactionalFile("/home/navid/output.text", "rw"))); + + CustomThread ct15 = new CustomThread(new thread1('o', new TransactionalFile("/home/navid/output.text", "rw"))); + CustomThread ct16 = new CustomThread(new thread1('p', new TransactionalFile("/home/navid/output.text", "rw"))); + CustomThread ct17 = new CustomThread(new thread1('q', new TransactionalFile("/home/navid/output.text", "rw"))); + CustomThread ct18 = new CustomThread(new thread1('r', new TransactionalFile("/home/navid/output.text", "rw"))); + + // CustomThread ct15 = new CustomThread(tr2); + CustomThread ct19 = new CustomThread(new thread1('s', new TransactionalFile("/home/navid/output.text", "rw"))); + CustomThread ct20 = new CustomThread(new thread1('t', new TransactionalFile("/home/navid/output.text", "rw")));*/ + + + CustomThread ct1 = new CustomThread(new thread1('a')); + CustomThread ct2 = new CustomThread(new thread1('b')); + CustomThread ct3 = new CustomThread(new thread1('c')); + CustomThread ct4= new CustomThread(new thread1('d')); + CustomThread ct5 = new CustomThread(new thread1('e')); + CustomThread ct6 = new CustomThread(new thread1('f')); + CustomThread ct7 = new CustomThread(new thread1('g')); + CustomThread ct8 = new CustomThread(new thread1('h')); + CustomThread ct9 = new CustomThread(new thread1('i')); + CustomThread ct10 = new CustomThread(new thread1('j')); + CustomThread ct11 = new CustomThread(new thread1('k')); + CustomThread ct12 = new CustomThread(new thread1('l')); + CustomThread ct13 = new CustomThread(new thread1('m')); + CustomThread ct14 = new CustomThread(new thread1('n')); + + CustomThread ct15 = new CustomThread(new thread1('o')); + CustomThread ct16 = new CustomThread(new thread1('p')); + CustomThread ct17 = new CustomThread(new thread1('q')); + CustomThread ct18 = new CustomThread(new thread1('r')); + + // CustomThread ct15 = new CustomThread(tr2); + CustomThread ct19 = new CustomThread(new thread1('s')); + CustomThread ct20 = new CustomThread(new thread1('t')); + + + //CustomThread ct4 = new CustomThread(tr3); + + // CustomThread ct5 = new CustomThread(tr4); + // CustomThread ct6 = new CustomThread(tr2); + + // CustomThread ct4 = new CustomThread(tr2); + ct1.runner.join(); + ct2.runner.join(); + ct3.runner.join(); + ct4.runner.join(); + ct5.runner.join(); + ct6.runner.join(); + ct7.runner.join(); + ct8.runner.join(); + ct9.runner.join(); + ct10.runner.join(); + ct11.runner.join(); + ct12.runner.join(); + ct13.runner.join(); + ct14.runner.join(); + + + + ct15.runner.join(); + ct16.runner.join(); + ct17.runner.join(); + ct18.runner.join(); + ct19.runner.join(); + + ct20.runner.join(); + + long endttime = System.nanoTime(); + // System.out.println(endttime - starttime); + System.out.println((endttime - starttime)/1000000); + //} + /* TreeMap msgs = new TreeMap(); + Iterator it = benchmark.transacctions.iterator(); + while(it.hasNext()){ + ExtendedTransaction tr = (ExtendedTransaction) it.next(); + msgs.putAll(tr.msg); + } + + Iterator it2 = msgs.keySet().iterator(); + while(it2.hasNext()){ + Long time = (Long) it2.next(); + System.out.print(time +" " + msgs.get(time)); + }*/ + int index =97; + for (int j = 0; j < 26; j++) { + ((TransactionalFile)(benchmark.m.get(String.valueOf((char) (index+j))))).close(); + } + // } + + //System.out.println(Thread.currentThread().getName()); + } catch (InterruptedException ex) { + Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex); + } + //System.out.println(Thread.currentThread().getName()); + + + } +} diff --git a/Robust/Transactions/TransactionalIOSrc/benchmarks/MainforLocks.java b/Robust/Transactions/TransactionalIOSrc/benchmarks/MainforLocks.java new file mode 100644 index 00000000..e74f4978 --- /dev/null +++ b/Robust/Transactions/TransactionalIOSrc/benchmarks/MainforLocks.java @@ -0,0 +1,142 @@ + +/* + * To change this template, choose Tools | Templates + * and open the template in the editor. + */ + +package TransactionalIO.benchmarks; + +import TransactionalIO.core.TransactionalFile; +import java.io.FileNotFoundException; +import java.io.RandomAccessFile; +import java.util.logging.Level; +import java.util.logging.Logger; + +/** + * + * @author navid + */ +public class MainforLocks { + + public static void main(String args[]){ + try { + RandomAccessFile file = new RandomAccessFile("/home/navid/randomwords.text", "rw"); + benchmark.init(); + long starttime = System.nanoTime(); + + // benchmark.filelock.writeLock().lock(); + lockthread1 thread1 = new lockthread1(file, 'a'); + // benchmark.filelock.writeLock().unlock(); + +// benchmark.filelock.writeLock().lock(); + lockthread1 thread2 = new lockthread1(file, 'b'); + // benchmark.filelock.writeLock().unlock(); + + // benchmark.filelock.writeLock().lock(); + lockthread1 thread3 = new lockthread1(file, 'c'); + // benchmark.filelock.writeLock().unlock(); + + // benchmark.filelock.writeLock().lock(); + lockthread1 thread4 = new lockthread1(file, 'd'); + // benchmark.filelock.writeLock().unlock(); + + // benchmark.filelock.writeLock().lock(); + lockthread1 thread5 = new lockthread1(file, 'e'); + // benchmark.filelock.writeLock().unlock(); + + // benchmark.filelock.writeLock().lock(); + lockthread1 thread6 = new lockthread1(file, 'f'); + // benchmark.filelock.writeLock().unlock(); + + // benchmark.filelock.writeLock().lock(); + lockthread1 thread7 = new lockthread1(file, 'g'); + // benchmark.filelock.writeLock().unlock(); + + // benchmark.filelock.writeLock().lock(); + lockthread1 thread8 = new lockthread1(file, 'h'); + // benchmark.filelock.writeLock().unlock(); + + // benchmark.filelock.writeLock().lock(); + lockthread1 thread9 = new lockthread1(file, 'i'); + // benchmark.filelock.writeLock().unlock(); + + // benchmark.filelock.writeLock().lock(); + lockthread1 thread10 = new lockthread1(file, 'j'); + // benchmark.filelock.writeLock().unlock(); + + // benchmark.filelock.writeLock().lock(); + lockthread1 thread11 = new lockthread1(file, 'k'); + // benchmark.filelock.writeLock().unlock(); + + // benchmark.filelock.writeLock().lock(); + lockthread1 thread12 = new lockthread1(file, 'l'); + // benchmark.filelock.writeLock().unlock(); + + // benchmark.filelock.writeLock().lock(); + lockthread1 thread13 = new lockthread1(file, 'm'); + // benchmark.filelock.writeLock().unlock(); + + // benchmark.filelock.writeLock().lock(); + lockthread1 thread14 = new lockthread1(file, 'n'); + // benchmark.filelock.writeLock().unlock(); + + // benchmark.filelock.writeLock().lock(); + lockthread1 thread15 = new lockthread1(file, 'o'); + // benchmark.filelock.writeLock().unlock(); + + // benchmark.filelock.writeLock().lock(); + lockthread1 thread16 = new lockthread1(file, 'p'); + // benchmark.filelock.writeLock().unlock(); + + // benchmark.filelock.writeLock().lock(); + lockthread1 thread17 = new lockthread1(file, 'q'); + // benchmark.filelock.writeLock().unlock(); + + // benchmark.filelock.writeLock().lock(); + lockthread1 thread18 = new lockthread1(file, 'r'); + // benchmark.filelock.writeLock().unlock(); + + // benchmark.filelock.writeLock().lock(); + lockthread1 thread19 = new lockthread1(file, 's'); + // benchmark.filelock.writeLock().unlock(); + + // benchmark.filelock.writeLock().lock(); + lockthread1 thread20 = new lockthread1(file, 't'); + // benchmark.filelock.writeLock().unlock(); + + thread1.join(); + thread2.join(); + thread3.join(); + thread4.join(); + thread5.join(); + thread6.join(); + thread7.join(); + thread8.join(); + thread9.join(); + thread10.join(); + thread11.join(); + thread12.join(); + thread13.join(); + thread14.join(); + thread15.join(); + thread16.join(); + thread17.join(); + thread18.join(); + thread19.join(); + thread20.join(); + + long endttime = System.nanoTime(); + System.out.println(endttime - starttime); + System.out.println((endttime - starttime) / 1000000); + int index =97; + for (int j = 0; j < 26; j++) { + ((TransactionalFile)(benchmark.m.get(String.valueOf((char) (index+j))))).close(); + } + } catch (InterruptedException ex) { + Logger.getLogger(MainforLocks.class.getName()).log(Level.SEVERE, null, ex); + } catch (FileNotFoundException ex) { + Logger.getLogger(MainforLocks.class.getName()).log(Level.SEVERE, null, ex); + } + + } +} diff --git a/Robust/Transactions/TransactionalIOSrc/benchmarks/StatisticsWrapper.java b/Robust/Transactions/TransactionalIOSrc/benchmarks/StatisticsWrapper.java new file mode 100644 index 00000000..5fcf21cd --- /dev/null +++ b/Robust/Transactions/TransactionalIOSrc/benchmarks/StatisticsWrapper.java @@ -0,0 +1,17 @@ +/* + * To change this template, choose Tools | Templates + * and open the template in the editor. + */ + +package TransactionalIO.benchmarks; + +/** + * + * @author navid + */ +public class StatisticsWrapper { + + public static int totalcommitted; + public static int totalaborted; + +} diff --git a/Robust/Transactions/TransactionalIOSrc/benchmarks/benchmark.java b/Robust/Transactions/TransactionalIOSrc/benchmarks/benchmark.java new file mode 100644 index 00000000..b611e141 --- /dev/null +++ b/Robust/Transactions/TransactionalIOSrc/benchmarks/benchmark.java @@ -0,0 +1,270 @@ +/* + * To change this template, choose Tools | Templates + * and open the template in the editor. + */ + +package TransactionalIO.benchmarks; + +import TransactionalIO.core.Defaults; +import TransactionalIO.core.TransactionalFile; +import java.io.FileNotFoundException; +import java.io.IOException; +import java.io.RandomAccessFile; +import java.util.Collections; +import java.util.HashMap; +import java.util.Map; +import java.util.Random; +import java.util.Vector; +import java.util.concurrent.locks.Lock; +import java.util.concurrent.locks.ReentrantLock; +import java.util.concurrent.locks.ReentrantReadWriteLock; +import java.util.logging.Level; +import java.util.logging.Logger; + + +/** + * + * @author navid + */ +public class benchmark { + static public HashMap TransactionalFiles = new HashMap(); + static public HashMap hotwords = new HashMap(); + static public HashMap names = new HashMap(); + static public HashMap reversenames = new HashMap(); + static int count = 0; + public static String msg = new String(); + public static ReentrantLock lock = new ReentrantLock(); + public static Vector transacctions = new Vector(); + public static ReentrantLock filelock = new ReentrantLock(); + public static Map m; + public static Map m2; + public static Map m3; + public static Map m4; + public static String[] stocks; + + + public benchmark() { + + } + + private static void preparenamelist(){ + try { + byte[] data = new byte[1]; + char[] name = new char[20]; + RandomAccessFile file = new RandomAccessFile("/home/navid/namelist.text", "rw"); + RandomAccessFile file2 = new RandomAccessFile("/home/navid/financialtransaction.text", "rw"); + RandomAccessFile file3 = new RandomAccessFile("/home/navid/accountbalance.text", "rw"); + + + stocks = new String[20]; + stocks[0] = "Yahoo"; + stocks[1] = "Google"; + stocks[2] = "Microsoft"; + stocks[3] = "Broadcom"; + stocks[4] = "Sun"; + stocks[5] = "Qualcom"; + stocks[6] = "Intel"; + stocks[7] = "WaMU"; + stocks[8] = "BoA"; + stocks[9] = "IMU"; + stocks[10] = "BMW"; + stocks[11] = "Nokia"; + stocks[12] = "Motorolla"; + stocks[13] = "Samsung"; + stocks[14] = "TMobile"; + stocks[15] = "ATT"; + stocks[16] = "PRops"; + stocks[17] = "Asia"; + stocks[18] = "LOLa"; + stocks[19] = "Brita"; + /* boolean hh = false; + boolean found = false; + while (true) { + + if (found){ + System.out.println(file4.getFilePointer()-1); + file4.seek(file4.getFilePointer()-1); + file4.write(' '); + file4.write(stocks[(int)(Math.random()*10)].getBytes()); + file4.write('\n'); + } + if (hh) + break; + found = false; + data[0] = 'a'; + while (data[0] != '\n') { + int tt =0; + tt = file4.read(data); + found = true; + if (tt == -1) { + hh = true; + break; + } + } + }*/ + + boolean flag = false; + boolean done = false; + int wordcounter = 0; + int counter =0; + while(true){ + if (flag) + break; + if (done){ + // System.out.println("At " + wordcounter + " inserted " +String.copyValueOf(name, 0, counter)); + m3.put(Integer.valueOf(wordcounter), String.copyValueOf(name, 0, counter)); + m4.put(String.copyValueOf(name, 0, counter), Integer.valueOf(wordcounter)); + wordcounter++; + done = false; + } + counter = 0; + data[0] = 'a'; + while (data[0] != '\n') { + int res; + res = file.read(data); + if (res == -1) { + flag = true; + break; + } + //System.out.println((char)data[0]); + if (!(Character.isLetter((char) data[0]))) { + continue; + } + name[counter] = (char)data[0]; + done = true; + counter++; + } + } + + + /* counter = 0; + while (counter <30000) { + int index1 = (int)(Math.random()*50); + int stocktrade = (int)(Math.random()*100); + while (stocktrade == 0) + stocktrade = (int)(Math.random()*100); + int index2 = (int)(Math.random()*50); + while (index2 == index1) + index2 = (int)(Math.random()*50); + //System.out.println(index); + String towrite = (String)m3.get(Integer.valueOf(index1)) + " "; + towrite += String.valueOf(stocktrade) + " "; + towrite += (String)m3.get(Integer.valueOf(index2)) + " "; + towrite += stocks[(int)(Math.random()*20)] + "\n"; + + file2.write(towrite.getBytes()); + // System.out.println(towrite); + counter++; + }*/ + // for (int i=0; i<50*Defaults.FILEFRAGMENTSIZE; i++) + //file3.write(''); + + + for (int i=0; i<50; i++){ + String towrite = (String)m3.get(Integer.valueOf(i)) +"\n"; + for (int j=0; j readers; + private Vector blockreaders; + + public static enum MODE {READ, WRITE, READ_WRITE}; + private MODE accessmode; + + protected BlockDataStructure(INode inode, int blocknumber) { + version = new AtomicInteger(0); + //lock = new ReentrantReadWriteLock(); + blockreaders = new Vector(); + lock = new ReentrantReadWriteLock(); + this.inode = inode; + this.blocknumber = blocknumber; + referncount = 0; + owner = null; + } + + public Vector getReaders() { + return blockreaders; + } + + public void setReaders(Vector readers) { + this.blockreaders = readers; + } + + public ReentrantReadWriteLock getLock() { + return lock; + } + + public void setLock(ReentrantReadWriteLock lock) { + this.lock = lock; + } + + public synchronized ExtendedTransaction getOwner() { + return owner; + } + + public synchronized void setOwner(ExtendedTransaction owner) { + this.owner = owner; + } + + public INode getInode() { + return inode; + } + + public void setInode(INode inode) { + this.inode = inode; + } + + public int getBlocknumber() { + return blocknumber; + } + + public void setBlocknumber(int blocknumber) { + this.blocknumber = blocknumber; + } + + public AtomicInteger getVersion() { + return version; + } + + public void setVersion(AtomicInteger version) { + this.version = version; + } + + public MODE getAccessmode() { + return accessmode; + } + + public void setAccessmode(MODE accessmode) { + this.accessmode = accessmode; + } + + public synchronized int getReferncount() { + return referncount; + } + + public synchronized void setReferncount(int referncount) { + this.referncount = referncount; + } + + + +} diff --git a/Robust/Transactions/TransactionalIOSrc/core/CustomLock.java b/Robust/Transactions/TransactionalIOSrc/core/CustomLock.java new file mode 100644 index 00000000..265716bf --- /dev/null +++ b/Robust/Transactions/TransactionalIOSrc/core/CustomLock.java @@ -0,0 +1,62 @@ +/* + * To change this template, choose Tools | Templates + * and open the template in the editor. + */ + +package TransactionalIO.core; + + +import TransactionalIO.benchmarks.benchmark; +import TransactionalIO.benchmarks.thread1; +import TransactionalIO.interfaces.TransactionalProgram; + +/** + * + * @author navid + */ +public class CustomLock implements Runnable{ + + private static ThreadLocal transactioncontainer = new ThreadLocal(); + private TransactionalProgram ioprogram; + private static ThreadLocal/**/ program = new ThreadLocal(); + private ExtendedTransaction transaction; + public Thread runner; + + + public CustomLock(TransactionalProgram ioprogram) { + this.ioprogram = ioprogram; + transaction = new ExtendedTransaction(); + runner = new Thread(this); + runner.start(); + } + + public static void setTransaction(ExtendedTransaction transaction){ + transactioncontainer.set(transaction); + } + + public static ExtendedTransaction getTransaction(){ + return (ExtendedTransaction) transactioncontainer.get(); + } + + public static void setProgram(TransactionalProgram transaction){ + program.set(transaction); + } + + public static TransactionalProgram getProgram(){ + return (TransactionalProgram) program.get(); + } + + + public void run() { + setTransaction(transaction); + setProgram(ioprogram); + synchronized(benchmark.lock){ + benchmark.transacctions.add(transaction); + } +// System.out.println(Thread.currentThread().getName()); + ioprogram.execute(); + transaction.prepareCommit(); + transaction.commitChanges(); + } + +} diff --git a/Robust/Transactions/TransactionalIOSrc/core/CustomThread.java b/Robust/Transactions/TransactionalIOSrc/core/CustomThread.java new file mode 100644 index 00000000..429f34c0 --- /dev/null +++ b/Robust/Transactions/TransactionalIOSrc/core/CustomThread.java @@ -0,0 +1,113 @@ +/* + * To change this template, choose Tools | Templates + * and open the template in the editor. + */ + +package TransactionalIO.core; + +import TransactionalIO.exceptions.AbortedException; +import TransactionalIO.benchmarks.benchmark; +import TransactionalIO.interfaces.TransactionalProgram; +import java.io.IOException; +import java.util.Vector; + +/** + * + * @author navid + */ +public class CustomThread implements Runnable{ + + + private static ThreadLocal transactioncontainer = new ThreadLocal(); + private static ThreadLocal onAbort = new ThreadLocal(); + private TransactionalProgram ioprogram; + private static ThreadLocal/**/ program = new ThreadLocal(); + private ExtendedTransaction transaction; + public Thread runner; + + + + public CustomThread(TransactionalProgram ioprogram) { + this.ioprogram = ioprogram; + runner = new Thread(this); + runner.start(); + } + + + + /* public static void setTransaction(ExtendedTransaction transaction){ + transactioncontainer.set(transaction); + } + + public static ExtendedTransaction getTransaction(){ + return (ExtendedTransaction) transactioncontainer.get(); + }*/ + + public static void setProgram(TransactionalProgram transaction){ + program.set(transaction); + } + + public static TransactionalProgram getProgram(){ + return (TransactionalProgram) program.get(); + } + + public static Vector getonAbort(){ + return (Vector) onAbort.get(); + } + + public static void setonAbort(Vector s){ + onAbort.set(s); + } + + + public void run() { + + setProgram(ioprogram); + // setonAbort(new Vector()); +// System.out.println(Thread.currentThread().getName()); + while (true){ + try{ + /* getonAbort().add(new terminateHandler() { + public void cleanup() { + synchronized(benchmark.lock){ + System.out.println(Thread.currentThread() +" KEWL"); + } + } + }); + */ + + Wrapper.Initialize(null); + // transaction = new ExtendedTransaction(); + // setTransaction(transaction); + synchronized(benchmark.lock){ + benchmark.transacctions.add(Wrapper.getTransaction()); + } + ioprogram.execute(); + Wrapper.prepareIOCommit(); + + Wrapper.commitIO(); + break; + } + catch (AbortedException e){ + /* Iterator it = getonAbort().iterator(); + while(it.hasNext()) { + terminateHandler th = (terminateHandler)it.next(); + th.cleanup(); + } + getonAbort().clear();*/ + + + /* synchronized(benchmark.lock){ + System.out.println(Thread.currentThread() +" retried"); + }*/ + + } + finally{ + Wrapper.getTransaction().unlockAllLocks(); + } + } + } + + + +} diff --git a/Robust/Transactions/TransactionalIOSrc/core/Defaults.java b/Robust/Transactions/TransactionalIOSrc/core/Defaults.java new file mode 100644 index 00000000..cf8d075e --- /dev/null +++ b/Robust/Transactions/TransactionalIOSrc/core/Defaults.java @@ -0,0 +1,73 @@ +package TransactionalIO.core; + +/* + * Defaults.java + * + * Copyright 2006 Sun Microsystems, Inc., 4150 Network Circle, Santa + * Clara, California 95054, U.S.A. All rights reserved. + * + * Sun Microsystems, Inc. has intellectual property rights relating to + * technology embodied in the product that is described in this + * document. In particular, and without limitation, these + * intellectual property rights may include one or more of the + * U.S. patents listed at http://www.sun.com/patents and one or more + * additional patents or pending patent applications in the U.S. and + * in other countries. + * + * U.S. Government Rights - Commercial software. + * Government users are subject to the Sun Microsystems, Inc. standard + * license agreement and applicable provisions of the FAR and its + * supplements. Use is subject to license terms. Sun, Sun + * Microsystems, the Sun logo and Java are trademarks or registered + * trademarks of Sun Microsystems, Inc. in the U.S. and other + * countries. + * + * This product is covered and controlled by U.S. Export Control laws + * and may be subject to the export or import laws in other countries. + * Nuclear, missile, chemical biological weapons or nuclear maritime + * end uses or end users, whether direct or indirect, are strictly + * prohibited. Export or reexport to countries subject to + * U.S. embargo or to entities identified on U.S. export exclusion + * lists, including, but not limited to, the denied persons and + * specially designated nationals lists is strictly prohibited. + */ + + + +/** + * + * @author Maurice Herlihy + */ + + +public class Defaults { + /** + * how many threads + **/ + public static final int THREADS = 1; + /** + * benchmark duration in milliseconds + **/ + public static final int TIME = 10000; + /** + * uninterpreted arg passed to benchmark + **/ + public static final int EXPERIMENT = 100; + /** + * fully-qualified contention manager name + **/ + public static final String MANAGER = "dstm2.manager.BackoffManager"; + /** + * fully-qualified factory name + **/ + public static final String FACTORY = "dstm2.factory.shadow.Factory"; + /** + * fully-qualified adapter name + **/ + public static final String ADAPTER = "dstm2.factory.shadow.Adapter";; + + public static final int FILEFRAGMENTSIZE= 1024; + + public static final boolean READWRITECONFLIT = true; + +} diff --git a/Robust/Transactions/TransactionalIOSrc/core/ExtendedTransaction.java b/Robust/Transactions/TransactionalIOSrc/core/ExtendedTransaction.java new file mode 100644 index 00000000..42b757ab --- /dev/null +++ b/Robust/Transactions/TransactionalIOSrc/core/ExtendedTransaction.java @@ -0,0 +1,971 @@ +/* + * To change this template, choose Tools | Templates + * and open the template in the editor. + */ +package TransactionalIO.core; + + + + + +import TransactionalIO.exceptions.AbortedException; +import TransactionalIO.benchmarks.benchmark; +import TransactionalIO.benchmarks.customhandler; +import TransactionalIO.benchmarks.customhandler; +import TransactionalIO.interfaces.BlockAccessModesEnum; +import TransactionalIO.interfaces.ContentionManager; +import TransactionalIO.interfaces.TransactionStatu; +//import dstm2.file.managers.BaseManager; +import java.awt.event.ActionListener; +import java.beans.EventHandler; +import java.beans.PropertyChangeEvent; +import java.beans.PropertyChangeListener; +import java.beans.PropertyChangeSupport; +import java.io.FileDescriptor; +import java.io.IOException; +import java.io.RandomAccessFile; +import java.util.Collections; +import java.util.HashMap; +import java.util.Iterator; +import java.util.Map; +import java.util.TreeMap; +import java.util.Vector; +import java.util.concurrent.locks.Lock; +import java.util.concurrent.locks.ReentrantLock; +import java.util.concurrent.locks.ReentrantReadWriteLock; +import java.util.logging.Level; +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; + 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}; + private boolean writesmerged = true; + + //private Vector heldoffsetlocks; + private Vector heldoffsetlocks; + + //private Vector heldblocklocks; + private Vector heldblocklocks; + + //private HashMap> AccessedFiles; + private HashMap AccessedFiles; + + + //private HashMap > accessedBlocks; + 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(); + AccessedFiles = new HashMap(); + GlobaltoLocalMappings = new HashMap/**/(); + writeBuffer = new HashMap(); + status = Status.ACTIVE; + accessedBlocks = new HashMap(); + merge_for_writes_done = new HashMap(); + writesmerged = true; + // setContentionmanager(new BaseManager()); + // beginTransaction(); + + } + + 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 ; + } + + 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(){ + this.addPropertyChangeListener(new customhandler(Status.ABORTED)); + } + + + + + public void abort() { + synchronized(this){ + // Status oldst = getStatus(); + /* synchronized(benchmark.lock){ + System.out.println("be ga raftim 0"); + }*/ + this.status = Status.ABORTED; + if (this.memorystate !=null && !(this.memorystate).isAborted()){ + /* synchronized(benchmark.lock){ + System.out.println(Thread.currentThread() +" be ga raftim 1 file"); + }*/ + 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; + } + + public void setWritesmerged(boolean writesmerged) { + this.writesmerged = writesmerged; + } + + + + + + + public HashMap getGlobaltoLocalMappings() { + return GlobaltoLocalMappings; + } + + public HashMap getAccessedBlocks() { + return accessedBlocks; + } + + + public ContentionManager getBlockContentionManager(){ + return ManagerRepository.getBlockcm(); + } + + 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){ + Status oldst = getStatus(); + this.status = st; + this.changes.firePropertyChange("status", oldst, st); + } + + + + + public void addFile(TransactionalFile tf/*, TransactionLocalFileAttributes tmp*/) { + + + /* if (tf.appendmode) { + this.addtoFileAccessModeMap(tf.getInode(), FileAccessModesEum.APPEND); + } else if (tf.writemode) { + this.addtoFileAccessModeMap(tf.getInode(), FileAccessModesEum.READ_WRITE); + } else { + this.addtoFileAccessModeMap(tf.getInode(), FileAccessModesEum.READ); + }*/ + // System.out.println("dsadssasadssa"); + + tf.lockOffset(this); + + //tf.offsetlock.lock(); + TransactionLocalFileAttributes tmp = new TransactionLocalFileAttributes(tf.getCommitedoffset().getOffsetnumber()/*, tf.getInodestate().commitedfilesize.get()*/); + //this.heldoffsetlocks.remove(tf.offsetlock); + tf.offsetlock.unlock(); + + Vector dummy; + + if (AccessedFiles.containsKey(tf.getInode())){ + dummy = (Vector) AccessedFiles.get(tf.getInode()); + } + else{ + dummy = new Vector(); + AccessedFiles.put(tf.getInode(), dummy); + } + + + + // this.msg.put(System.nanoTime(), Thread.currentThread().getName() + " Unlocked the offset lock " + tf.offsetlock + " for file " + tf.getInode() + " form descriptor " + tf.getSequenceNum()); + dummy.add(tf); + GlobaltoLocalMappings.put(tf, tmp); + 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(); + + 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()){ + TransactionalFile value = (TransactionalFile) it.next(); + while (this.getStatus() ==Status.ACTIVE){ + //if (value.offsetlock.tryLock()) { + 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(); + } + } + } + } + getOffsetContentionManager().resolveConflict(this, value.getCurrentcommitedoffset().getOffsetOwner()); + } + return true; + } */ + + /*public boolean commit() { /// Locking offsets for File Descriptors with checking strategy + + 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); + } + } + }*/ + + + + + 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 { + + 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); + } + + 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) + 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(); + 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()){ + + value = (WriteOperations) it.next(); + 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); + 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); + } + + 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) + sset.put(Integer.valueOf(i), BlockAccessModesEnum.READ_WRITE); + } + 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); + // } + // + + } + } + + /*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); + + } catch (IOException ex) { + Logger.getLogger(ExtendedTransaction.class.getName()).log(Level.SEVERE, null, ex); + } + + } 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(); + + + value.f.seek(range.getStart() + tobeaddedoffset); + + 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); + + for (int i = 0; i < data.length; i++) { + bytedata[i] = data[i]; + } + value.f.write(bytedata); + counter++; + + } catch (IOException ex) { + Logger.getLogger(ExtendedTransaction.class.getName()).log(Level.SEVERE, null, ex); + } + } + } else { + continue; + } + } + + + 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()){ + 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()); + }*/ + // } + } + //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); + }*/ + } + 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"); + // } + } + heldoffsetlocks.clear(); + } + + public void abortAllReaders(){ + TreeMap hm = getSortedFileAccessMap(AccessedFiles); + //lock phase + Iterator iter = hm.keySet().iterator(); + TransactionalFile value; + while (iter.hasNext()) { + 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(); + } + value.getCommitedoffset().getOffsetReaders().clear(); + //} + } + + + + TreeMap vec2; + if (accessedBlocks.get(key) != null){ + vec2 = (TreeMap) accessedBlocks.get(key); + } + 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()) + { + + ExtendedTransaction tr = (ExtendedTransaction) it4.next(); + 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 removePropertyChangeListener(PropertyChangeListener listener){ + this.changes.removePropertyChangeListener("status",listener); + } + + public TransactionStatu getOtherSystem() { + return memorystate; + } + + public void setOtherSystem(TransactionStatu othersystem) { + memorystate = othersystem; + } + + public Vector getHeldblocklocks() { + return heldblocklocks; + } + + public void setHeldblocklocks(Vector heldblocklocks) { + this.heldblocklocks = heldblocklocks; + } + + public Vector getHeldoffsetlocks() { + return heldoffsetlocks; + } + + public void setHeldoffsetlocks(Vector heldoffsetlocks) { + this.heldoffsetlocks = heldoffsetlocks; + } + + public void abortThisSystem() { + abort(); + } + + public boolean isCommitted() { + if (this.status == Status.COMMITTED) + return true; + + return false; + + } + + + +} + + + + + + diff --git a/Robust/Transactions/TransactionalIOSrc/core/FileBlockManager.java b/Robust/Transactions/TransactionalIOSrc/core/FileBlockManager.java new file mode 100644 index 00000000..bff7234d --- /dev/null +++ b/Robust/Transactions/TransactionalIOSrc/core/FileBlockManager.java @@ -0,0 +1,34 @@ +/* + * To change this template, choose Tools | Templates + * and open the template in the editor. + */ +package TransactionalIO.core; + +//import Defaults; + + + + + + + + + +/** + * + * @author navid + */ +public class FileBlockManager { + + public static long getFragmentIndexofTheFile(long filesize) { + return (filesize / Defaults.FILEFRAGMENTSIZE); + } + + public static int getCurrentFragmentIndexofTheFile(long start) { + return (int) ((start / Defaults.FILEFRAGMENTSIZE)); + } + + public static int getTargetFragmentIndexofTheFile(long start, long offset) { + return (int) (((offset + start) / Defaults.FILEFRAGMENTSIZE)); + } +} diff --git a/Robust/Transactions/TransactionalIOSrc/core/GlobalINodeState.java b/Robust/Transactions/TransactionalIOSrc/core/GlobalINodeState.java new file mode 100644 index 00000000..f3705a9e --- /dev/null +++ b/Robust/Transactions/TransactionalIOSrc/core/GlobalINodeState.java @@ -0,0 +1,118 @@ +/* + * Adapter.java + * + * Copyright 2006 Sun Microsystems, Inc., 4150 Network Circle, Santa + * Clara, California 95054, U.S.A. All rights reserved. + * + * Sun Microsystems, Inc. has intellectual property rights relating to + * technology embodied in the product that is described in this + * document. In particular, and without limitation, these + * intellectual property rights may include one or more of the + * U.S. patents listed at http://www.sun.com/patents and one or more + * additional patents or pending patent applications in the U.S. and + * in other countries. + * + * U.S. Government Rights - Commercial software. + * Government users are subject to the Sun Microsystems, Inc. standard + * license agreement and applicable provisions of the FAR and its + * supplements. Use is subject to license terms. Sun, Sun + * Microsystems, the Sun logo and Java are trademarks or registered + * trademarks of Sun Microsystems, Inc. in the U.S. and other + * countries. + * + * This product is covered and controlled by U.S. Export Control laws + * and may be subject to the export or import laws in other countries. + * Nuclear, missile, chemical biological weapons or nuclear maritime + * end uses or end users, whether direct or indirect, are strictly + * prohibited. Export or reexport to countries subject to + * U.S. embargo or to entities identified on U.S. export exclusion + * lists, including, but not limited to, the denied persons and + * specially designated nationals lists is strictly prohibited. + */ +package TransactionalIO.core; + +import java.util.Collections; +import java.util.HashMap; +import java.util.Map; +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.atomic.AtomicLong; + +/** + * Obstruction-free atomic object implementation. Visible reads. + * Support snapshots and early release. + * @author Navid Farri + */ +public class GlobalINodeState { + + // public HashMap lockmap; + public HashMap lockmap; + private ConcurrentHashMap conlockmap = new ConcurrentHashMap(); + + public AtomicLong commitedfilesize = new AtomicLong(); + private ExtendedTransaction writer; + public int seqNum = 0; + private INode inode; + + public GlobalINodeState() { + } + + + + + protected GlobalINodeState(INode inode, long length) { + writer = null; + lockmap = new HashMap(); + + commitedfilesize.set(length); + this.inode = inode; + } + + + + + public AtomicLong getCommitedfilesize() { + return commitedfilesize; + } + + public void setCommitedfilesize(AtomicLong commitedfilesize) { + this.commitedfilesize = commitedfilesize; + } + + public ExtendedTransaction getWriter() { + return writer; + } + + public void setWriter(ExtendedTransaction writer) { + this.writer = writer; + } + + public BlockDataStructure getBlockDataStructure(Integer blocknumber) { + /* synchronized (lockmap) { + if (lockmap.containsKey(blocknumber)) { + return ((BlockDataStructure) (lockmap.get(blocknumber))); + } else { + BlockDataStructure tmp = new BlockDataStructure(inode, blocknumber); + lockmap.put(blocknumber, tmp); + return tmp; + } + } + }*/ + BlockDataStructure rec = (BlockDataStructure)conlockmap.get(blocknumber); + if (rec == null) { + // record does not yet exist + BlockDataStructure newRec = new BlockDataStructure(inode, blocknumber); + rec = (BlockDataStructure)conlockmap.putIfAbsent(blocknumber, newRec); + if (rec == null) { + // put succeeded, use new value + rec = newRec; + } + } + return rec; +} + + + + + +} + diff --git a/Robust/Transactions/TransactionalIOSrc/core/GlobalOffset.java b/Robust/Transactions/TransactionalIOSrc/core/GlobalOffset.java new file mode 100644 index 00000000..f32ffe3b --- /dev/null +++ b/Robust/Transactions/TransactionalIOSrc/core/GlobalOffset.java @@ -0,0 +1,52 @@ +/* + * To change this template, choose Tools | Templates + * and open the template in the editor. + */ + +package TransactionalIO.core; + +import java.util.Vector; + +/** + * + * @author navid + */ +public class GlobalOffset { + private long offsetnumber; + //private Vector offsetReaders; + private Vector offsetReaders = new Vector(); + private ExtendedTransaction offsetOwner; + + public GlobalOffset(long offsetnumber) { + this.offsetnumber = offsetnumber; + } + + + public long getOffsetnumber() { + return offsetnumber; + } + + public ExtendedTransaction getOffsetOwner(){ + return offsetOwner; + } + + public void setOffsetOwner(ExtendedTransaction ex){ + offsetOwner = ex; + } + + public void setOffsetnumber(long offsetnumber) { + this.offsetnumber = offsetnumber; + } + + public Vector getOffsetReaders() { + return offsetReaders; + } + + public void setOffsetReaders(Vector offsetReaders) { + this.offsetReaders = offsetReaders; + } + + + + +} diff --git a/Robust/Transactions/TransactionalIOSrc/core/HelloWorld.c b/Robust/Transactions/TransactionalIOSrc/core/HelloWorld.c new file mode 100644 index 00000000..35fa4e02 --- /dev/null +++ b/Robust/Transactions/TransactionalIOSrc/core/HelloWorld.c @@ -0,0 +1,9 @@ +#include +#include +#include "HelloWorld.h" + +JNIEXPORT void JNICALL Java_HelloWorld_displayMessage(JNIEnv *env, jobject obj){ + printf("HelloWorld!\n"); +} + + diff --git a/Robust/Transactions/TransactionalIOSrc/core/HelloWorld.h b/Robust/Transactions/TransactionalIOSrc/core/HelloWorld.h new file mode 100644 index 00000000..7cdd58e3 --- /dev/null +++ b/Robust/Transactions/TransactionalIOSrc/core/HelloWorld.h @@ -0,0 +1,19 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ + +#include + +#ifndef __dstm2_file_factory_HelloWorld__ +#define __dstm2_file_factory_HelloWorld__ + +#ifdef __cplusplus +extern "C" +{ +#endif + +JNIEXPORT void JNICALL Java_dstm2_file_factory_HelloWorld_displayMessage (JNIEnv *env, jobject); + +#ifdef __cplusplus +} +#endif + +#endif /* __dstm2_file_factory_HelloWorld__ */ diff --git a/Robust/Transactions/TransactionalIOSrc/core/INode.java b/Robust/Transactions/TransactionalIOSrc/core/INode.java new file mode 100644 index 00000000..e5a1f826 --- /dev/null +++ b/Robust/Transactions/TransactionalIOSrc/core/INode.java @@ -0,0 +1,61 @@ +/* + * To change this template, choose Tools | Templates + * and open the template in the editor. + */ + +package TransactionalIO.core; + +/** + * + * @author navid + */ +public class INode implements Comparable{ + + private String filepath; + private long number; + + + public INode(long number) { + this.number = number; + } + + public INode(long number, String filepath) { + this(number); + this.filepath = filepath; + } + + public String getFilepath() { + return filepath; + } + + public void setFilepath(String filepath) { + this.filepath = filepath; + } + + + + public long getNumber() { + return number; + } + + public void setNumber(long number) { + this.number = number; + } + + public int compareTo(Object arg0) { + INode other = (INode) arg0; + if (this.getNumber() < other.getNumber()) + return -1; + else if (this.getNumber() > other.getNumber()) + return 1; + else{ + System.out.println("Logical Eroor Two Inodes cannot have the same number"); + return 0; + } + + } + + + + +} diff --git a/Robust/Transactions/TransactionalIOSrc/core/IOlib b/Robust/Transactions/TransactionalIOSrc/core/IOlib new file mode 100644 index 0000000000000000000000000000000000000000..cc5c990759a2d182f979f4cc5f116586cac30770 GIT binary patch literal 24696 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 RaSwhmzL + #include + #include + #include "NativeFunctions.h" + + JNIEXPORT jlong JNICALL Java_test2_Main_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; + } + return inodenum; + } diff --git a/Robust/Transactions/TransactionalIOSrc/core/NativeFunctions.h b/Robust/Transactions/TransactionalIOSrc/core/NativeFunctions.h new file mode 100644 index 00000000..4d9b0a28 --- /dev/null +++ b/Robust/Transactions/TransactionalIOSrc/core/NativeFunctions.h @@ -0,0 +1,19 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ + +#include + +#ifndef __test2_Main__ +#define __test2_Main__ + +#ifdef __cplusplus +extern "C" +{ +#endif + +JNIEXPORT jlong JNICALL test2_Main_getINodeNative (JNIEnv *env, jobject, jstring); + +#ifdef __cplusplus +} +#endif + +#endif /* __HellWorld__ */ diff --git a/Robust/Transactions/TransactionalIOSrc/core/NativeFunctions.o b/Robust/Transactions/TransactionalIOSrc/core/NativeFunctions.o new file mode 100644 index 0000000000000000000000000000000000000000..b799c0af5b3ca7419f83e3fbb37089908be92ec2 GIT binary patch literal 23672 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 XKHg~+t#!wWOphH)(U*q(>a9jFpY literal 0 HcmV?d00001 diff --git a/Robust/Transactions/TransactionalIOSrc/core/TransactionLocalFileAttributes.java b/Robust/Transactions/TransactionalIOSrc/core/TransactionLocalFileAttributes.java new file mode 100644 index 00000000..3da69130 --- /dev/null +++ b/Robust/Transactions/TransactionalIOSrc/core/TransactionLocalFileAttributes.java @@ -0,0 +1,77 @@ +/* + * To change this template, choose Tools | Templates + * and open the template in the editor. + */ +package TransactionalIO.core; + + +import TransactionalIO.interfaces.OffsetDependency; +import java.io.RandomAccessFile; + +/** + * + * @author navid + */ +public class TransactionLocalFileAttributes { + + + private INode inode; + public boolean to_be_created = false; + RandomAccessFile f; + OffsetDependency offsetdependency; + private long copylocaloffset; + private boolean unknown_inital_offset_for_write = true; + private long localoffset; + private long localsize; + + public TransactionLocalFileAttributes(long initialoffset/*, long initialsize*/){ + localoffset = initialoffset; + copylocaloffset = initialoffset; + //copylocaloffset = 0; + unknown_inital_offset_for_write = true; + offsetdependency = OffsetDependency.NO_ACCESS; + //localsize = initialsize; + } + + public long getCopylocaloffset() { + return copylocaloffset; + } + + public void setCopylocaloffset(long copylocaloffset) { + this.copylocaloffset = copylocaloffset; + } + + public long getLocalsize() { + return localsize; + } + + public void setLocalsize(long localsize) { + this.localsize = localsize; + } + + + public OffsetDependency getOffsetdependency() { + return offsetdependency; + } + + public void setOffsetdependency(OffsetDependency offsetdependency) { + this.offsetdependency = offsetdependency; + } + + public boolean isUnknown_inital_offset_for_write() { + return unknown_inital_offset_for_write; + } + + public void setUnknown_inital_offset_for_write(boolean unknown_inital_offset_for_write) { + this.unknown_inital_offset_for_write = unknown_inital_offset_for_write; + } + + public long getLocaloffset() { + return localoffset; + } + + public void setLocaloffset(long localoffset) { + this.localoffset = localoffset; + } + +} diff --git a/Robust/Transactions/TransactionalIOSrc/core/TransactionalFile.java b/Robust/Transactions/TransactionalIOSrc/core/TransactionalFile.java new file mode 100644 index 00000000..72cdf445 --- /dev/null +++ b/Robust/Transactions/TransactionalIOSrc/core/TransactionalFile.java @@ -0,0 +1,1592 @@ +/* + * To change this template, choose Tools | Templates + * and open the template in the editor. + */ +package TransactionalIO.core; + + + +import TransactionalIO.Utilities.Range; +import TransactionalIO.exceptions.AbortedException; +import TransactionalIO.exceptions.PanicException; +import TransactionalIO.benchmarks.benchmark; +import TransactionalIO.core.ExtendedTransaction.Status; +import TransactionalIO.interfaces.BlockAccessModesEnum; +import TransactionalIO.interfaces.OffsetDependency; +import com.sun.org.apache.bcel.internal.generic.IFEQ; +import java.io.File; +import java.io.FileDescriptor; +import java.io.FileNotFoundException; +import java.io.IOException; +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{ + + + private native int nativepread(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 static int currenSeqNumforInode = 0; + /* public AtomicLong commitedoffset; + public AtomicLong commitedfilesize;*/ + public boolean to_be_created = false; + public boolean writemode = false; + public boolean appendmode = false; + public ReentrantLock offsetlock; + private GlobalOffset committedoffset; + private GlobalINodeState inodestate ; + + + public TransactionalFile(String filename, String mode) { + + + File f = new File(filename); + + if ((!(f.exists()))) { + to_be_created = true; + file = null; + + } else { + + try { + + 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")) { + appendmode = true; + } + + if (inodestate != null) { + synchronized (inodestate) { + try { + // if (!(to_be_created)) { + // } else { + // adapter.commitedfilesize.set(0); + // } + + if (!appendmode) { + //commitedoffset.setOffsetnumber(0); + committedoffset = new GlobalOffset(0); + } else { + committedoffset = new GlobalOffset(file.length()); + } + + } catch (IOException ex) { + Logger.getLogger(TransactionalFile.class.getName()).log(Level.SEVERE, null, ex); + } + } + } + + + } + + 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 getSequenceNum() { + return sequenceNum; + } + + + public GlobalOffset getCommitedoffset() { + return committedoffset; + } + + public GlobalINodeState getInodestate() { + return inodestate; + } + + /* public TransactionalFile(Adapter adapter, RandomAccessFile file) { + + this.adapter = adapter; + this.file = file; + decriptors = new Vector(); + } + + public void copyTransactionalFile(TransactionalFile tf){ + try { + int tmp = tf.commitedoffset.get(); + boolean flag = tf.to_be_created; + FileDescriptor fd = tf.file.getFD(); + Adapter ad = new Adapter(tf.adapter); + } catch (IOException ex) { + Logger.getLogger(TransactionalFile.class.getName()).log(Level.SEVERE, null, ex); + } + }*/ + + /* public BlockDataStructure getBlockDataStructure(int blocknumber) { + synchronized (inodestate.lockmap) { + if (inodestate.lockmap.containsKey(blocknumber)) { + + return ((BlockDataStructure) (inodestate.lockmap.get(Long.valueOf(blocknumber)))); + } else { + + BlockDataStructure tmp = new BlockDataStructure(getInode(), blocknumber); + inodestate.lockmap.put(Integer.valueOf(blocknumber), tmp); + return tmp; + } + } + + }*/ + + + + public INode getInode() { + return inode; + } + /* public boolean deleteBlockLock(int blocknumber){ + synchronized(adapter.lockmap){ + //adapter.lockmap.get(blocknumber) + if (adapter.lockmap.containsKey(blocknumber)){ + if (((BlockLock)(adapter.lockmap.get(blocknumber))).referncount == 0){ + adapter.lockmap.remove(adapter.lockmap.get(blocknumber)); + return true; + } + else + return false; + } + else { + return false; + } + } + }*/ + public void close() { + try { + file.close(); + } catch (IOException ex) { + Logger.getLogger(TransactionalFile.class.getName()).log(Level.SEVERE, null, ex); + } + } + + public long getFilePointer(){ + + ExtendedTransaction me = Wrapper.getTransaction(); + TransactionLocalFileAttributes tmp = null; + + if (me == null) { + return non_Transactional_getFilePointer(); + } + + if (!(me.getGlobaltoLocalMappings().containsKey(this))){ + + //if (!(me.getFilesAccesses().containsKey(this.inode))) { + tmp = new TransactionLocalFileAttributes(0);/*, tf.getInodestate().commitedfilesize.get();*/ + + Vector dummy; + if (me.getAccessedFiles().containsKey(this.getInode())){ + dummy = (Vector) me.getAccessedFiles().get(this.getInode()); + } + else{ + dummy = new Vector(); + me.getAccessedFiles().put(this.getInode(), dummy); + } + + + + // this.msg.put(System.nanoTime(), Thread.currentThread().getName() + " Unlocked the offset lock " + tf.offsetlock + " for file " + tf.getInode() + " form descriptor " + tf.getSequenceNum()); + dummy.add(this); + me.getGlobaltoLocalMappings().put(this, tmp); + me.merge_for_writes_done.put(this.getInode(), Boolean.TRUE); + + // me.addFile(this); + + //me.addFile(this); + } + + tmp = (TransactionLocalFileAttributes) me.getGlobaltoLocalMappings().get(this); + if ((tmp.getOffsetdependency() == OffsetDependency.WRITE_DEPENDENCY_1) || (tmp.getOffsetdependency() == OffsetDependency.NO_ACCESS)){ + tmp.setOffsetdependency(OffsetDependency.READ_DEPENDENCY); + //System.out.println("sad"); + //synchronized(this.committedoffset) + long target; + lockOffset(me); + //{ + + if (!(this.committedoffset.getOffsetReaders().contains(me))){ + this.committedoffset.getOffsetReaders().add(me); + /*synchronized(benchmark.lock){ + benchmark.msg += Thread.currentThread().getName() + " Added to Offset Readers for file " + this.inode + " from descriptor "+ this.sequenceNum +"\n"; + }*/ + // me.msg.put(System.nanoTime(), Thread.currentThread().getName() + " Added to Offset Readers for file " + this.inode + " from descriptor "+ this.sequenceNum +"\n"); + /* synchronized(benchmark.lock){ + System.out.println(Thread.currentThread().getName() + " Added to Offset Readers for file " + this.inode + " from descriptor "+ this.sequenceNum +"\n"); + }*/ + } + + tmp.setLocaloffset(tmp.getLocaloffset() + this.committedoffset.getOffsetnumber() - tmp.getCopylocaloffset()); + target = this.committedoffset.getOffsetnumber() - tmp.getCopylocaloffset(); + + + offsetlock.unlock(); + //me.getHeldoffsetlocks().remove(offsetlock); + + Iterator it; + + if ((me.getWriteBuffer().get(inode)) != null) + { + + it = ((Vector) (me.getWriteBuffer().get(inode))).iterator(); + while (it.hasNext()){ + WriteOperations wrp = (WriteOperations) it.next(); + if (wrp.getBelongingto() == tmp && wrp.isUnknownoffset()) + wrp.setUnknownoffset(false); + /*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());*/ + wrp.getRange().setStart(target + wrp.getRange().getStart()); + wrp.getRange().setEnd(target + wrp.getRange().getEnd()); + } + } + + + //} + } + + + tmp.setUnknown_inital_offset_for_write(false); + + /* synchronized(benchmark.lock){ + benchmark.msg += Thread.currentThread().getName() + " Read the offset value for the file " + this.inode +" from descriptor " + this.sequenceNum + "\n"; + } + me.msg += Thread.currentThread().getName() + " Read the offset value for the file " + this.inode +" from descriptor " + this.sequenceNum + "\n";*/ + /* synchronized(benchmark.lock){ + System.out.println("offset " + Thread.currentThread() + " " + tmp.getLocaloffset()); + }*/ + return tmp.getLocaloffset(); + } + + public void seek(long offset) { + + if (appendmode) { + throw new PanicException("Cannot seek into a file opened in append mode"); + } + ExtendedTransaction me = Wrapper.getTransaction(); + + if (me == null) { + non_Transactional_Seek(offset); + return; + } + + else { + // if (me.getStatus() != Status.ACTIVE) + // throw new AbortedException(); + + TransactionLocalFileAttributes tmp = null; + //tf.offsetlock.lock(); + + //this.heldoffsetlocks.remove(tf.offsetlock); + //tf.offsetlock.unlock(); + if (!(me.getGlobaltoLocalMappings().containsKey(this))){ + //if (!(me.getFilesAccesses().containsKey(this.inode))) { + tmp = new TransactionLocalFileAttributes(offset);/*, tf.getInodestate().commitedfilesize.get();*/ + + Vector dummy; + if (me.getAccessedFiles().containsKey(this.getInode())){ + dummy = (Vector) me.getAccessedFiles().get(this.getInode()); + } + else{ + dummy = new Vector(); + me.getAccessedFiles().put(this.getInode(), dummy); + } + + + + // this.msg.put(System.nanoTime(), Thread.currentThread().getName() + " Unlocked the offset lock " + tf.offsetlock + " for file " + tf.getInode() + " form descriptor " + tf.getSequenceNum()); + dummy.add(this); + me.getGlobaltoLocalMappings().put(this, tmp); + me.merge_for_writes_done.put(this.getInode(), Boolean.TRUE); + + //me.addFile(this); + } + tmp = (TransactionLocalFileAttributes) me.getGlobaltoLocalMappings().get(this); + //tmp = ((TransactionLocalFileAttributes) (me.getFilesAccesses().get(this.getInode()))); + + if (tmp.getOffsetdependency() == OffsetDependency.NO_ACCESS) + tmp.setOffsetdependency(OffsetDependency.NO_DEPENDENCY); + + else if (tmp.getOffsetdependency() == OffsetDependency.WRITE_DEPENDENCY_1) + tmp.setOffsetdependency(OffsetDependency.WRITE_DEPENDENCY_2); + + tmp.setUnknown_inital_offset_for_write(false); + + tmp.setLocaloffset(offset); + + + /* synchronized(benchmark.lock){ + System.out.println(tmp.getLocaloffset()); + }*/ + // me.msg.put(System.nanoTime(), Thread.currentThread().getName() + " Seeked to the file" + this.inode +" from descriptor " + this.sequenceNum + "\n"); + } + } + + public int read(byte[] b) { + + if (appendmode) { + throw new PanicException("Cannot seek into a file opened in append mode"); + } + + boolean firsttime = false; + ExtendedTransaction me = Wrapper.getTransaction(); + 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.getStatus() != Status.ACTIVE) + // throw new AbortedException(); + + + if (me.getGlobaltoLocalMappings().containsKey(this)){ + + /*long target; + Vector locktracker = new Vector(); + TreeMap hm = me.getSortedFileAccessMap(me.getAccessedFiles());; + Vector vec = (Vector)hm.get(inode); + Iterator vecit = vec.iterator(); + while(vecit.hasNext()){ + TransactionalFile tr = (TransactionalFile)vecit.next(); + TransactionLocalFileAttributes tmp = (TransactionLocalFileAttributes) me.getGlobaltoLocalMappings().get(tr); + + if ((tmp.getOffsetdependency() == OffsetDependency.WRITE_DEPENDENCY_1) || (tmp.offsetdependency == OffsetDependency.NO_ACCESS) || (tmp.getOffsetdependency() == OffsetDependency.WRITE_DEPENDENCY_2)){ + tmp.setUnknown_inital_offset_for_write(false); + tmp.setOffsetdependency(OffsetDependency.READ_DEPENDENCY); + tr.lockOffset(me); + System.out.printtln(Thread.currentThread() + " kiri"); + if (!(tr.committedoffset.getOffsetReaders().contains(me))){ + tr.committedoffset.getOffsetReaders().add(me); + target = this.committedoffset.getOffsetnumber() - tmp.getCopylocaloffset(); + me.msg.put(System.nanoTime(), Thread.currentThread().getName() + " Added to Offset Readers for file " + this.inode + " from descriptor "+ this.sequenceNum +"\n"); + } + } + }*/ + + + + + TransactionLocalFileAttributes tmp = (TransactionLocalFileAttributes) me.getGlobaltoLocalMappings().get(this); + tmp.setUnknown_inital_offset_for_write(false); + if ((tmp.getOffsetdependency() == OffsetDependency.WRITE_DEPENDENCY_1) || (tmp.offsetdependency == OffsetDependency.NO_ACCESS) || (tmp.getOffsetdependency() == OffsetDependency.WRITE_DEPENDENCY_2)){ + //System.out.println(Thread.currentThread() + " here"); + //synchronized(this.committedoffset){ + lockOffset(me); + if (tmp.getOffsetdependency() != OffsetDependency.WRITE_DEPENDENCY_2){ + tmp.setLocaloffset(tmp.getLocaloffset() + this.committedoffset.getOffsetnumber() - tmp.getCopylocaloffset()); + } + + tmp.setOffsetdependency(OffsetDependency.READ_DEPENDENCY); + if (!(this.committedoffset.getOffsetReaders().contains(me))){ + this.committedoffset.getOffsetReaders().add(me); + /* synchronized(benchmark.lock){ + System.out.println("adding offset " + committedoffset + " " +Thread.currentThread()); + }*/ + /* synchronized(benchmark.lock){ + benchmark.msg += Thread.currentThread().getName() + " Added to Offset Readers for file " + this.inode + " from descriptor "+ this.sequenceNum +"\n"; + }*/ + // me.msg.put(System.nanoTime(), Thread.currentThread().getName() + " Added to Offset Readers for file " + this.inode + " from descriptor "+ this.sequenceNum +"\n"); + /*synchronized(benchmark.lock){ + System.out.println(Thread.currentThread().getName() + " Added to Offset Readers for file " + this.inode + " from descriptor "+ this.sequenceNum); + }*/ + } + + offsetlock.unlock(); + // me.getHeldoffsetlocks().remove(offsetlock); + //} + } + Iterator it; + if (me.getWriteBuffer().get(inode) != null) + //if (!(((Vector)(me.getWriteBuffer().get(inode))).isEmpty())) + { + it = ((Vector) (me.getWriteBuffer().get(inode))).iterator(); + while (it.hasNext()){ + + WriteOperations wrp = (WriteOperations) it.next(); + if (wrp.isUnknownoffset()){ + wrp.setUnknownoffset(false); + //synchronized(wrp.getOwnertransactionalFile().committedoffset){ + 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()); + /* synchronized(benchmark.lock){ + benchmark.msg += Thread.currentThread().getName() + " Added to Offset Readers for file " + this.inode + " from descriptor "+ wrp.getOwnertransactionalFile().sequenceNum +"\n"; + }*/ + // me.msg.put(System.nanoTime(), Thread.currentThread().getName() + " Added to Offset Readers for file " + this.inode + " from descriptor "+ wrp.getOwnertransactionalFile().sequenceNum +"\n"); + } + + // me.getHeldoffsetlocks().remove(wrp.getOwnertransactionalFile().offsetlock); + wrp.getOwnertransactionalFile().offsetlock.unlock(); + + //} + + + + markAccessedBlocks(me, (int)wrp.getRange().getStart(), (int)(wrp.getRange().getEnd() - wrp.getRange().getStart()), BlockAccessModesEnum.WRITE); +// markWriteBlocks((int)wrp.getRange().getStart(), (int)(wrp.getRange().getEnd() - wrp.getRange().getStart())); + } + } + } + + /* if (!(me.isWritesmerged())){ + // synchronized(benchmark.lock){ + // System.out.println("ssssad " + Thread.currentThread() + " " + me.getWriteBuffer()); + // } + mergeWrittenData(); + }*/ + // System.out.println("ssssad " + Thread.currentThread() + " " + me.getWriteBuffer()); + if ((Boolean)me.merge_for_writes_done.get(inode) == Boolean.FALSE){ + // synchronized(benchmark.lock){ + System.out.println("ssssad " + Thread.currentThread() + " " + me.getWriteBuffer()); + mergeWrittenData(me); + //} + } + + + long loffset = tmp.getLocaloffset(); + markAccessedBlocks(me, loffset, size, BlockAccessModesEnum.READ); + + + Vector writebuffer; + if ((me.getWriteBuffer().get(this.inode)) != null) + writebuffer = (Vector) (me.getWriteBuffer().get(this.inode)); + else { + writebuffer = new Vector(); + me.getWriteBuffer().put(this.inode, writebuffer); + } + Range readrange = new Range(loffset, loffset + size); + Range writerange = null; + Range[] intersectedrange = new Range[writebuffer.size()]; + WriteOperations[] markedwriteop = new WriteOperations[writebuffer.size()]; + + int counter = 0; + + + + + boolean flag = false; + //System.out.println("yani che>??"); + + it = writebuffer.iterator(); + while (it.hasNext()) { + + WriteOperations wrp = (WriteOperations) it.next(); + writerange = wrp.getRange(); + if (writerange.includes(readrange)) { + markedwriteop[counter] = wrp; + flag = true; + break; + } + + if (writerange.hasIntersection(readrange)) { + intersectedrange[counter] = readrange.intersection(writerange); + markedwriteop[counter] = wrp; + + counter++; + } + } + + + // for block versioning mechanism + /*if (!(validateBlocksVersions(startblock, targetblock))) { ////check to see if version are still valid + + throw new AbortedException(); + + }*/ + if (flag) { + + result = readFromBuffer(b, tmp, markedwriteop[counter],writerange); + + /* synchronized(benchmark.lock){ + benchmark.msg += Thread.currentThread().getName() + " Read " + this.inode + " from descriptor "+ this.sequenceNum +"\n"; + }*/ + + // me.msg.put(System.nanoTime(), Thread.currentThread().getName() + " Read " + this.inode + " from descriptor "+ this.sequenceNum +"\n"); + return result; + } + + else{ + + if (counter == 0) { + /* synchronized(benchmark.lock){ + System.out.println("here" +Thread.currentThread()); + }*/ + + // lockOffset(me); + result = readFromFile(me, b, tmp); + } + else { + + for (int i = 0; i < counter; i++) { + + + Byte[] data = markedwriteop[i].getData(); + byte[] copydata = new byte[data.length]; + + for (int j = 0; j < data.length; j++) { + copydata[j] = data[j].byteValue(); + } + System.arraycopy(copydata, (int) (intersectedrange[i].getStart() - markedwriteop[i].getRange().getStart()), b, (int) (intersectedrange[i].getStart() - readrange.getStart()), (int) (Math.min(intersectedrange[i].getEnd(), readrange.getEnd()) - intersectedrange[i].getStart())); + result += Math.min(intersectedrange[i].getEnd(), readrange.getEnd()) - intersectedrange[i].getStart(); + } + + Range[] non_intersected_ranges = readrange.minus(intersectedrange, counter); + Vector occupiedblocks = new Vector(); + Vector heldlocks = new Vector(); + for (int i = 0; i < non_intersected_ranges.length; i++) { + int st = FileBlockManager.getCurrentFragmentIndexofTheFile(non_intersected_ranges[i].getStart()); + int en = FileBlockManager.getCurrentFragmentIndexofTheFile(non_intersected_ranges[i].getEnd()); + for (int j = st; j <= en; j++) { + if (!(occupiedblocks.contains(Integer.valueOf(j)))) { + occupiedblocks.add(Integer.valueOf(j)); + } + } + } + + + + lockOffset(me); + me.getHeldoffsetlocks().add(offsetlock); + + + for (int k = 0; k < occupiedblocks.size(); k++) { // locking the block locks + + while (me.getStatus() == Status.ACTIVE) { + + BlockDataStructure block = this.inodestate.getBlockDataStructure((Integer)(occupiedblocks.get(k)));//(BlockDataStructure) tmp.adapter.lockmap.get(Integer.valueOf(k))); + + //synchronized(block){ + + // if (block.getLock().readLock().tryLock()) { + block.getLock().readLock().lock(); + /* synchronized(benchmark.lock){ + benchmark.msg += Thread.currentThread().getName() + " Locked The Block Number " + block.getBlocknumber()+ " for file " + this.inode + " from descriptor "+ this.sequenceNum +"\n"; + }*/ + // me.msg.put(System.nanoTime(), Thread.currentThread().getName() + " Added The Block Number " + block.getBlocknumber()+ " for file " + this.inode + " from descriptor "+ this.sequenceNum +"\n"); + //synchronized (block){ + if (!(block.getReaders().contains(me))){ + /* synchronized(benchmark.lock){ + benchmark.msg += Thread.currentThread().getName() + " Added to Block Readers for Block Number " + block.getBlocknumber()+ " for file " + this.inode + " from descriptor "+ this.sequenceNum +"\n"; + }*/ + // me.msg.put(System.nanoTime(), Thread.currentThread().getName() + " Added to Block Readers for Block Number " + block.getBlocknumber()+ " for file " + this.inode + " from descriptor "+ this.sequenceNum +"\n"); + block.getReaders().add(me); + } + me.getHeldblocklocks().add(block.getLock().readLock()); + //heldlocks.add(block.getLock().readLock()); + //} + break; + // } + //} else { + // me.getContentionmanager().resolveConflict(me, block); + // } + //} + } + if (me.getStatus() == Status.ABORTED) { + //unlockLocks(heldlocks); + //offsetlock.unlock(); + // me.msg.put(System.nanoTime(), Thread.currentThread().getName() + " Aborted in locking blocks in read\n"); + /* synchronized(benchmark.lock){ + benchmark.msg += Thread.currentThread().getName() + " Aborted \n"; + }*/ + // Thread.currentThread().stop(); + 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(); + } + } + }*/ + + + for (int i = 0; i < non_intersected_ranges.length; i++) { + try { + synchronized(benchmark.lock){ + System.out.println("read start " + non_intersected_ranges[i].getStart()); + } + 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) { + + //unlockLocks(heldlocks); + //offsetlock.unlock(); + Logger.getLogger(TransactionalFile.class.getName()).log(Level.SEVERE, null, ex); + } + } + me.unlockAllLocks(); + tmp.setLocaloffset(tmp.getLocaloffset() + result); + // unlockLocks(heldlocks); + // offsetlock.unlock(); + } + /*synchronized(benchmark.lock){ + benchmark.msg += Thread.currentThread().getName() + " Read from file " + this.inode + " from descriptor "+ this.sequenceNum +"\n"; + }*/ + // me.msg.put(System.nanoTime(), Thread.currentThread().getName() + " Read from file " + this.inode + " from descriptor "+ this.sequenceNum +"\n"); + return result; + } + + } else { // add to the readers list + System.out.println("form read???"); + me.addFile(this); + return read(b); + } + + } + + public void write(byte[] data) throws IOException { + + if (!(writemode)) { + throw new IOException(); + + } + + ExtendedTransaction me = Wrapper.getTransaction(); + int size = data.length; + + + if (me == null) // not a transaction + { + + non_Transactional_Write(data); + return; + } + + //else if (me.getFilesAccesses().containsKey(this.getInode())) // + //{ + // if (me.getStatus() != Status.ACTIVE) + // throw new AbortedException(); + + 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))); + + /*if (appendmode) { + newwriterange = new Range((((Range) (tm.firstKey())).getStart()), (((Range) (tm.firstKey())).getEnd()) + size); + Range range = new Range((((Range) (tm.firstKey())).getStart()), (((Range) (tm.firstKey())).getEnd())); + Byte[] appenddata = new Byte[(int) (newwriterange.getEnd() - newwriterange.getStart())]; + Byte[] tempor = new Byte[(int) (range.getEnd() - range.getStart())]; + System.arraycopy(tempor, 0, appenddata, 0, tempor.length); + System.arraycopy(by, 0, appenddata, tempor.length, by.length); + tm.remove(range); + tm.put(newwriterange, appenddata); + tmp.setLocaloffset(loffset + size); + tmp.setFilelength(tmp.getFilelength() + size); + + return; + }*/ + Vector dummy; + if (((Vector)(me.getWriteBuffer().get(this.inode))) != null){ + dummy = new Vector((Vector)(me.getWriteBuffer().get(this.inode))); + } + else + dummy = new Vector(); + /* synchronized(benchmark.lock){ + System.out.println(Thread.currentThread() + " gg " + tmp.getLocaloffset() + " " + (tmp.getLocaloffset()+by.length)); + }*/ + /*if (!(tmp.isUnknown_inital_offset_for_write())){ + lockOffset(me); + tmp.setLocaloffset(this.committedoffset.getOffsetnumber()); + offsetlock.unlock(); + }*/ + + 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); + //me.setWritesmerged(false); + + + + if (!(tmp.isUnknown_inital_offset_for_write())){ + markAccessedBlocks(me, loffset, size, BlockAccessModesEnum.WRITE); +// markWriteBlocks(loffset, size); + } + /*{ + int startblock = FileBlockManager.getCurrentFragmentIndexofTheFile(loffset); + int targetblock = FileBlockManager.getTargetFragmentIndexofTheFile(loffset, size); + for (int i = startblock; i <= targetblock; i++) { + if (me.getAccessedBlocks().containsKey(Integer.valueOf(i))) { + if (((BlockAccessModesEnum) (me.getAccessedBlocks().get(Integer.valueOf(i)))) == BlockAccessModesEnum.READ) { + me.getAccessedBlocks().put(Integer.valueOf(i), BlockAccessModesEnum.READ_WRITE); + } + } else { + me.getAccessedBlocks().put(Integer.valueOf(i), BlockAccessModesEnum.WRITE); + // tmp.getBlockversions().put(Integer.valueOf(i), Integer.valueOf(getBlockDataStructure(i).getVersion().get())); //For Block Versioning Mechanism + } + } + }*/ + + if (tmp.getOffsetdependency() == OffsetDependency.NO_ACCESS) + tmp.offsetdependency = OffsetDependency.WRITE_DEPENDENCY_1; + + + + /*if ((tmp.access_from_absolute_offset) || !(tmp.relocatablewrite)) + { + int startblock = FileBlockManager.getCurrentFragmentIndexofTheFile(loffset); + int targetblock = FileBlockManager.getTargetFragmentIndexofTheFile(loffset, size); + for (int i = startblock; i <= targetblock; i++) { + if (tmp.getAccesedblocks().containsKey(Integer.valueOf(i))) { + if (((BlockAccessModesEnum) (tmp.getAccesedblocks().get(Integer.valueOf(i)))) == BlockAccessModesEnum.READ) { + tmp.getAccesedblocks().put(Integer.valueOf(i), BlockAccessModesEnum.READ_WRITE); + } + } else { + tmp.getAccesedblocks().put(Integer.valueOf(i), BlockAccessModesEnum.WRITE); + // tmp.getBlockversions().put(Integer.valueOf(i), Integer.valueOf(getBlockDataStructure(i).getVersion().get())); //For Block Versioning Mechanism + } + } + } + + if (tmp.access_from_absolute_offset){ + + mergeWrittenData(tmp.getNon_Speculative_Writtendata(), data, newwriterange); + tmp.setLocaloffset(loffset + size); + if (tmp.getLocaloffset() > tmp.getFilelength()) { + tmp.setFilelength(tmp.getLocaloffset()); + } + return; + } + + else // for comtimious determingin the accessed block is postpond till commit instant + { + Byte[] dd = new Byte[size]; + System.arraycopy(by, 0, dd, 0, size); + if (!(tmp.getSpeculative_Writtendata().isEmpty())){ + + Range lastrange = (Range) tmp.getSpeculative_Writtendata().lastKey(); + if (lastrange.getEnd() == newwriterange.getStart()){ + dd = new Byte[(int)(size + lastrange.getEnd() - lastrange.getStart())]; + System.arraycopy(((Byte[])tmp.getSpeculative_Writtendata().get(lastrange)), 0, dd, 0, (int)(lastrange.getEnd() - lastrange.getStart())); + System.arraycopy(by, 0, dd, (int)(lastrange.getEnd() - lastrange.getStart()), size); + newwriterange = new Range(lastrange.getStart(), size + lastrange.getEnd()); + tmp.getSpeculative_Writtendata().remove(lastrange); + } + + } + + tmp.getSpeculative_Writtendata().put(newwriterange, dd); + + tmp.setLocaloffset(loffset + size); + if (tmp.getLocaloffset() > tmp.getFilelength()) { + tmp.setFilelength(tmp.getLocaloffset()); + } + + return; + } + + */ + + /* + + if (tmp.accessmode == TransactionLocalFileAttributes.MODE.READ) + tmp.accessmode = TransactionLocalFileAttributes.MODE.READ_WRITE; + else if (tmp.accessmode == TransactionLocalFileAttributes.MODE.WRITE) + simpleWritetoBuffer(by, newwriterange, tm); + */ + // me.msg.put(System.nanoTime(), Thread.currentThread().getName() + " Writes to " + this.inode + " from descriptor "+ this.sequenceNum +"\n"); + + } else { + // System.out.println("form write??"); + // me.addFile(this/*, TransactionLocalFileAttributes.MODE.WRITE*/); + //if (!(me.getGlobaltoLocalMappings().containsKey(this))){ + //if (!(me.getFilesAccesses().containsKey(this.inode))) { + TransactionLocalFileAttributes tmp = new TransactionLocalFileAttributes(0);/*, tf.getInodestate().commitedfilesize.get();*/ + + Vector dummy; + if (me.getAccessedFiles().containsKey(this.getInode())){ + dummy = (Vector) me.getAccessedFiles().get(this.getInode()); + } + else{ + dummy = new Vector(); + me.getAccessedFiles().put(this.getInode(), dummy); + } + + + + // this.msg.put(System.nanoTime(), Thread.currentThread().getName() + " Unlocked the offset lock " + tf.offsetlock + " for file " + tf.getInode() + " form descriptor " + tf.getSequenceNum()); + dummy.add(this); + me.getGlobaltoLocalMappings().put(this, tmp); + me.merge_for_writes_done.put(this.getInode(), Boolean.TRUE); + + //me.addFile(this); + //} + + write(data); + } + /* synchronized(benchmark.lock){ + benchmark.msg += Thread.currentThread().getName() + " Writes to " + this.inode + " from descriptor "+ this.sequenceNum +"\n"; + }*/ + + + } + + + private void markAccessedBlocks(ExtendedTransaction me,long loffset, int size, BlockAccessModesEnum mode){ + + TreeMap map; + + if (me.getAccessedBlocks().get(this.getInode()) != null) + map = (TreeMap) me.getAccessedBlocks().get(this.getInode()); + 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){ + map.put(Integer.valueOf(i), BlockAccessModesEnum.READ_WRITE); + } + } + else{ + map.put(Integer.valueOf(i), mode); + } + } + /*int startblock = FileBlockManager.getCurrentFragmentIndexofTheFile(loffset); + int targetblock = FileBlockManager.getTargetFragmentIndexofTheFile(loffset, size); + for (int i = startblock; i <= targetblock; i++) { + if (me.getAccessedBlocks().containsKey(Integer.valueOf(i))) { + if (((BlockAccessModesEnum) (me.getAccessedBlocks().get(Integer.valueOf(i)))) == BlockAccessModesEnum.READ) { + me.getAccessedBlocks().put(Integer.valueOf(i), BlockAccessModesEnum.READ_WRITE); + } + + + } else { + me.getAccessedBlocks().put(Integer.valueOf(i), BlockAccessModesEnum.WRITE); + // tmp.getBlockversions().put(Integer.valueOf(i), Integer.valueOf(getBlockDataStructure(i).getVersion().get())); //For Block Versioning Mechanism + } + }*/ + } + +/* private void markWriteBlocks(long loffset, int size){ + ExtendedTransaction me = CustomThread.getTransaction(); + SortedSet tt; + if (me.writeBlocks.get(this.inode) != null) + tt = (SortedSet) me.writeBlocks.get(this.inode); + else { + tt = new TreeSet(); + me.writeBlocks.put(this.inode, tt); + } + + int startblock = FileBlockManager.getCurrentFragmentIndexofTheFile(loffset); + int targetblock = FileBlockManager.getTargetFragmentIndexofTheFile(loffset, size); + for (int i = startblock; i <= targetblock; i++) { + tt.add(Integer.valueOf(i)); + } + }*/ + + private int readFromFile(ExtendedTransaction me, byte[] readdata, TransactionLocalFileAttributes tmp) { + + + //ExtendedTransaction me = Wrapper.getTransaction(); + int st = FileBlockManager.getCurrentFragmentIndexofTheFile(tmp.getLocaloffset()); + int end = FileBlockManager.getTargetFragmentIndexofTheFile(tmp.getLocaloffset(), readdata.length); + + BlockDataStructure block = null; + boolean locked = false; + for (int k = st; k <= end; k++) { + // int expvalue = ((Integer) tmp.getBlockversions().get(Integer.valueOf(k))).intValue(); // all comments here for versioning mechanism + while (me.getStatus() == Status.ACTIVE) { + //BlockDataStructure block = ((BlockDataStructure) this.inodestate.lockmap.get(Integer.valueOf(k))); + // BlockDataStructure block; + //if (me.getAccessedBlocks().get(inode)) + block = this.inodestate.getBlockDataStructure(Integer.valueOf(k)); + + block.getLock().readLock().lock(); + // me.getHeldblocklocks().add(block.getLock().readLock()); + if (!(block.getReaders().contains(me))){ + block.getReaders().add(me); + } + locked = true; + // if (!(block.getVersion().get() == expvalue)) { + // me.abort(); + // } else { + break; + // } + // } + /* else { + me.getContentionmanager().resolveConflict(me, block); + }*/ + + } + if (me.getStatus() == Status.ABORTED) { + int m; + 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; + //System.out.println("wrp2 > wrp"); + + endsuffix = wrp2.getRange().getEnd(); + //suffixstart = (int) (intersectedrange[i].getEnd() - intersectedrange[i].getStart()); + } + + 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()); + // System.out.println("wrp2 < wrp"); + endsuffix = wrp.getRange().getEnd(); + suffix = true; + + } + /* System.out.println("prefix start:" + startprefix); + System.out.println("suffix end:" + endsuffix); + System.out.println("suffix start:" + startsuffix); + System.out.println("intermediate start:" + intermediatetart); + + System.out.println("suffix size:" + suffixsize);*/ + + + 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); + //me.setWritesmerged(true); + + /*} else if (prefix) { + data_to_insert = new Byte[(int) (to_be_merged_data_range.getStart() - start + size)]; + System.arraycopy(prefixdata, 0, data_to_insert, 0, (int) (to_be_merged_data_range.getStart() - start)); + System.arraycopy(by, 0, data_to_insert, (int) (to_be_merged_data_range.getStart() - start), size); + to_be_merged_data_range.setStart(start); + } else if (suffix) { + data_to_insert = new Byte[(int) (to_be_merged_data_range.getEnd() - end + size)]; + System.arraycopy(by, 0, data_to_insert, 0, size); + System.arraycopy(suffixdata, suffixstart, data_to_insert, size, (int) (end - to_be_merged_data_range.getEnd())); + to_be_merged_data_range.setEnd(end); + } else { + data_to_insert = new Byte[size]; + System.arraycopy(data_to_insert, (int) (to_be_merged_data_range.getStart() - start), by, 0, size); + }*/ + //target.put(to_be_merged_data_range, data_to_insert); + +/* + if (flag) { + int datasize = (int) (oldwriterange.getEnd() - oldwriterange.getStart()); + Byte[] original = (Byte[]) (wrp.getData()); + byte[] originaldata = new byte[datasize]; + + //for (int i = 0; i < data.length; i++) { + // originaldata[i] = original[i].byteValue(); + // } + System.arraycopy(data, 0, originaldata, (int) (to_be_merged_data_range.getStart() - oldwriterange.getStart()), size); + Byte[] to_be_inserted = new Byte[datasize]; + + for (int i = 0; i < datasize; i++) { + to_be_inserted[i] = Byte.valueOf(originaldata[i]); + } + target.put(oldwriterange, to_be_inserted); + return; + + } else if (counter == 0) { + target.put(to_be_merged_data_range, data); + return; + + } else { + + int suffixstart = 0; + long start = 0; + long end = 0; + Byte[] prefixdata = null; + Byte[] suffixdata = null; + boolean prefix = false; + boolean suffix = false; + + for (int i = 0; i < counter; i++) { + if (markedwriteranges[i].getStart() < to_be_merged_data_range.getStart()) { + prefixdata = new Byte[(int) (to_be_merged_data_range.getStart() - markedwriteranges[i].getStart())]; + prefixdata = (Byte[]) (target.get(markedwriteranges[i])); + start = markedwriteranges[i].getStart(); + //newdata = new Byte[size + newwriterange.getStart() - markedwriteranges[i].getStart()]; + //System.arraycopy(by, 0, newdata, newwriterange.getStart() - markedwriteranges[i].getStart(), size); + //System.arraycopy(originaldata, 0, newdata, 0, newwriterange.getStart() - markedwriteranges[i].getStart()); + + //newwriterange.setStart(markedwriteranges[i].getStart()); + prefix = true; + + + } else if (markedwriteranges[i].getEnd() > to_be_merged_data_range.getEnd()) { + + suffixdata = new Byte[(int) (markedwriteranges[i].getStart() - to_be_merged_data_range.getStart())]; + suffixdata = (Byte[]) (target.get(markedwriteranges[i])); + end = markedwriteranges[i].getEnd(); + + //Byte [] originaldata = (Byte [])(tmp.getWrittendata().get(markedwriteranges[i])); + //newdata = new Byte[size + newwriterange.getStart() - markedwriteranges[i].getStart()]; + //System.arraycopy(originaldata, 0, newdata, 0, newwriterange.getStart() - markedwriteranges[i].getStart()); + + //newwriterange.setStart(markedwriteranges[i].getStart()); + ///newwriterange.setEnd(markedwriteranges[i].getEnd()); + suffix = true; + suffixstart = (int) (intersectedrange[i].getEnd() - intersectedrange[i].getStart()); + //tm.remove(markedwriteranges[i]); + } + target.remove(markedwriteranges[i]); + + } + Byte[] data_to_insert; + + if ((prefix) && (suffix)) { + data_to_insert = new Byte[(int) (to_be_merged_data_range.getStart() - start + size - to_be_merged_data_range.getEnd() + end)]; + System.arraycopy(prefixdata, 0, data_to_insert, 0, (int) (to_be_merged_data_range.getStart() - start)); + System.arraycopy(by, 0, data_to_insert, (int) (to_be_merged_data_range.getStart() - start), size); + System.arraycopy(suffixdata, suffixstart, data_to_insert, (int) (size + to_be_merged_data_range.getStart() - start), (int) (end - to_be_merged_data_range.getEnd())); + to_be_merged_data_range.setStart(start); + to_be_merged_data_range.setEnd(end); + } else if (prefix) { + data_to_insert = new Byte[(int) (to_be_merged_data_range.getStart() - start + size)]; + System.arraycopy(prefixdata, 0, data_to_insert, 0, (int) (to_be_merged_data_range.getStart() - start)); + System.arraycopy(by, 0, data_to_insert, (int) (to_be_merged_data_range.getStart() - start), size); + to_be_merged_data_range.setStart(start); + } else if (suffix) { + data_to_insert = new Byte[(int) (to_be_merged_data_range.getEnd() - end + size)]; + System.arraycopy(by, 0, data_to_insert, 0, size); + System.arraycopy(suffixdata, suffixstart, data_to_insert, size, (int) (end - to_be_merged_data_range.getEnd())); + to_be_merged_data_range.setEnd(end); + } else { + data_to_insert = new Byte[size]; + System.arraycopy(data_to_insert, (int) (to_be_merged_data_range.getStart() - start), by, 0, size); + } + target.put(to_be_merged_data_range, data_to_insert); + return; + }*/ + + } + + public void non_Transactional_Write(byte[] data){ + + Vector heldlocks = new Vector(); + boolean flag = true; + 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); + //if (block.getLock().writeLock().tryLock()) { + block.getLock().writeLock().lock(); + heldlocks.add(block.getLock().writeLock()); + //} else { + // unlockLocks(heldlocks); + // offsetlock.unlock(); + // flag = false; + // break; + //} + } + + /*if (flag) { + throw new PanicException("The I/O operation could not be done to contention for the file"); + }*/ + + //else { + try { + + 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){ + int size = -1; + Vector heldlocks = new Vector(); + boolean flag = true; + offsetlock.lock(); + int startblock; + int targetblock; + startblock = FileBlockManager.getCurrentFragmentIndexofTheFile(committedoffset.getOffsetnumber()); + targetblock = FileBlockManager.getTargetFragmentIndexofTheFile(committedoffset.getOffsetnumber(), size); + /* long offset = committedoffset.getOffsetnumber(); + committedoffset.setOffsetnumber(committedoffset.getOffsetnumber() +b.length); + 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(); + } + offsetlock.unlock();*/ + + for (int i = startblock; i <= targetblock; i++) { + BlockDataStructure block = this.inodestate.getBlockDataStructure(i); + //if (block.getLock().readLock().tryLock()) { + block.getLock().readLock().lock(); + heldlocks.add(block.getLock().readLock()); + /*} else { + unlockLocks(heldlocks); + offsetlock.unlock(); + flag = false; + break; + }*/ + } + /*if (flag) { + size = -1; + } else {*/ + + + + // try { + //ByteBuffer buffer = ByteBuffer.wrap(b); + //System.out.println(committedoffset.getOffsetnumber()); + //size = file.getChannel().read(buffer, offset); + //file.seek(committedoffset.getOffsetnumber()); + // size = file.read(b); + 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()) + { + ExtendedTransaction tr = (ExtendedTransaction) it2.next(); + tr.abort(); + } + committedoffset.getOffsetReaders().clear(); + } + + // } catch (IOException ex) { + // Logger.getLogger(TransactionalFile.class.getName()).log(Level.SEVERE, null, ex); + // size = -1; + // } finally { + unlockLocks(heldlocks); + offsetlock.unlock(); + if (size == 0) + size = -1; + // } + // } + return size; + + } + + public void non_Transactional_Seek(long offset){ + offsetlock.lock(); + //try { + //file.seek(offset); + //synchronized(adapter){ + committedoffset.setOffsetnumber(offset); + // inodestate.commitedfilesize.set(offset); + //} + //} catch (IOException ex) { + /// Logger.getLogger(TransactionalFile.class.getName()).log(Level.SEVERE, null, ex); + //} finally { + offsetlock.unlock(); + //} + } + + public long non_Transactional_getFilePointer(){ + long offset = -1;; + offsetlock.lock(); + + + // try { + + //synchronized(adapter){ + offset = committedoffset.getOffsetnumber(); + //} + // } catch (IOException ex) { + // Logger.getLogger(TransactionalFile.class.getName()).log(Level.SEVERE, null, ex); + // } finally { + offsetlock.unlock(); + // } + return offset; + } + + public int compareTo(Object arg0) { + TransactionalFile tf = (TransactionalFile) arg0; + if (this.inode.getNumber() < tf.inode.getNumber()) + return -1; + else if (this.inode.getNumber() > tf.inode.getNumber()) + return 1; + else { + if (this.sequenceNum < tf.sequenceNum) + return -1; + else + return 1; + } + } + +} diff --git a/Robust/Transactions/TransactionalIOSrc/core/TransactionalFileWrapperFactory.java b/Robust/Transactions/TransactionalIOSrc/core/TransactionalFileWrapperFactory.java new file mode 100644 index 00000000..b684a556 --- /dev/null +++ b/Robust/Transactions/TransactionalIOSrc/core/TransactionalFileWrapperFactory.java @@ -0,0 +1,67 @@ +/* + * To change this template, choose Tools | Templates + * and open the template in the editor. + */ +package TransactionalIO.core; + +import java.io.File; +import java.util.HashMap; + +/** + * + * @author navid + */ +public class TransactionalFileWrapperFactory { + + + + private TransactionalFileWrapperFactory() { + } + // private static HashMap filemappings; + public static HashMap filemappings = new HashMap(); + + private static native long getINodeNative(String filename); + + static{ + //System.load("/home/navid/libnav.so"); + System.load("/home/navid/libnativeIO.so"); + } + + static INode getINodefromFileName(String filename) { + return new INode(getINodeNative(filename), filename); + } + + + + public synchronized static GlobalINodeState getTateransactionalFileINodeState(INode inode) { + + return (GlobalINodeState)filemappings.get(inode.getNumber()); + + } + public synchronized static GlobalINodeState createTransactionalFile(INode inode, String filename, String mode) { + + long inodenumber = inode.getNumber(); + if (inodenumber != -1) + + if (filemappings.containsKey(inode.getNumber())) { + // System.out.println("here"); + return (GlobalINodeState)filemappings.get(inode.getNumber()); + + } else { + + + long length = new File(filename).length(); + + GlobalINodeState inodestate = new GlobalINodeState(inode, length); + filemappings.put(inode.getNumber(), inodestate); + return inodestate; + } + + else + { + return null; + } + + } + +} diff --git a/Robust/Transactions/TransactionalIOSrc/core/Wrapper.java b/Robust/Transactions/TransactionalIOSrc/core/Wrapper.java new file mode 100644 index 00000000..b68f488e --- /dev/null +++ b/Robust/Transactions/TransactionalIOSrc/core/Wrapper.java @@ -0,0 +1,115 @@ +/* + * To change this template, choose Tools | Templates + * and open the template in the editor. + */ + +package TransactionalIO.core; + +import TransactionalIO.core.ExtendedTransaction; + +import TransactionalIO.core.CustomThread; +import TransactionalIO.interfaces.TransactionStatu; +import java.util.Vector; + + +/** + * + * @author navid + */ +public class Wrapper{ + + + private ExtendedTransaction transaction = new ExtendedTransaction(); + private static ThreadLocal IOtransactioncontainer = new ThreadLocal(); + private static ThreadLocal onMemoryAbort = new ThreadLocal(); + private static ThreadLocal onIOAbort = new ThreadLocal(); + + + + public static void prepareIOCommit(){ + + getTransaction().prepareCommit(); + } + + public static void commitIO(){ + getTransaction().commitChanges(); + } + + + + public static void Initialize(TransactionStatu memory){ + ExtendedTransaction transaction = new ExtendedTransaction(); + setTransaction(transaction); + transaction.setOtherSystem(memory); + + if (memory != null) + memory.setOtherSystem(transaction); + + + + /* setonIOAbort(new Vector()); + setonMemoryAbort(new Vector()); + + getonIOAbort().add(new terminateHandler() { + public void cleanup() { + Thread.getTransaction().abort(); + synchronized(benchmark.lock){ + System.out.println(Thread.currentThread() +" KEWL"); + } + } + }); + + getonMemoryAbort().add(new terminateHandler() { + public void cleanup() { + CustomThread.getTransaction().abort(); + synchronized(benchmark.lock){ + System.out.println(Thread.currentThread() +" KEWL"); + } + } + });*/ + } + + public static void memoryCommit(){ + + } + + + public static void setTransaction(ExtendedTransaction transaction){ + IOtransactioncontainer.set(transaction); + } + + + + public static ExtendedTransaction getTransaction(){ + return (ExtendedTransaction) IOtransactioncontainer.get(); + } + + public static void setonIOAbort(Vector vec){ + onIOAbort.set(vec); + } + + + private static Vector getonIOAbort(){ + return (Vector) onIOAbort.get(); + } + + public static void setonMemoryAbort(Vector vec){ + onMemoryAbort.set(vec); + } + + + private static Vector getonMemoryAbort(){ + return (Vector) onMemoryAbort.get(); + } + + + + + + + + +} + + + diff --git a/Robust/Transactions/TransactionalIOSrc/core/WriteOperations.java b/Robust/Transactions/TransactionalIOSrc/core/WriteOperations.java new file mode 100644 index 00000000..9a376675 --- /dev/null +++ b/Robust/Transactions/TransactionalIOSrc/core/WriteOperations.java @@ -0,0 +1,82 @@ +/* + * To change this template, choose Tools | Templates + * and open the template in the editor. + */ + +package TransactionalIO.core; + +import TransactionalIO.Utilities.Range; + +/** + * + * @author navid + */ +public class WriteOperations implements Comparable{ + + private Byte[] data; + private Range range; + private boolean unknownoffset; + private TransactionLocalFileAttributes belongingto; + private TransactionalFile ownertransactionalfile; + + public WriteOperations(Byte[] data, Range range, boolean unknownoffset, TransactionalFile ownertransactionalfile, TransactionLocalFileAttributes belongingto) { + this.data = data; + this.range = range; + this.unknownoffset = unknownoffset; + this.ownertransactionalfile = ownertransactionalfile; + this.belongingto = belongingto; + } + + public TransactionalFile getOwnertransactionalFile() { + return ownertransactionalfile; + } + + public void setOwnertransaction(TransactionalFile ownertransaction) { + this.ownertransactionalfile = ownertransaction; + } + + + + public Byte[] getData() { + return data; + } + + public Range getRange() { + return range; + } + + public boolean isUnknownoffset() { + return unknownoffset; + } + + public void setData(Byte[] data) { + this.data = new Byte[data.length]; + System.arraycopy(data, 0, this.data, 0, data.length); + } + + public void setRange(Range range) { + this.range = range; + } + + public void setUnknownoffset(boolean unknownoffset) { + this.unknownoffset = unknownoffset; + } + + public TransactionLocalFileAttributes getBelongingto() { + return belongingto; + } + + public void setBelongingto(TransactionLocalFileAttributes belongingto) { + this.belongingto = belongingto; + } + + + public int compareTo(Object other) { + WriteOperations tmp = (WriteOperations) other; + return this.range.compareTo(tmp.range); + } + + + + +} diff --git a/Robust/Transactions/TransactionalIOSrc/exceptions/PanicException.java b/Robust/Transactions/TransactionalIOSrc/exceptions/PanicException.java new file mode 100644 index 00000000..ed58fc60 --- /dev/null +++ b/Robust/Transactions/TransactionalIOSrc/exceptions/PanicException.java @@ -0,0 +1,69 @@ +/* + * PanicException.java + * + * Copyright 2006 Sun Microsystems, Inc., 4150 Network Circle, Santa + * Clara, California 95054, U.S.A. All rights reserved. + * + * Sun Microsystems, Inc. has intellectual property rights relating to + * technology embodied in the product that is described in this + * document. In particular, and without limitation, these + * intellectual property rights may include one or more of the + * U.S. patents listed at http://www.sun.com/patents and one or more + * additional patents or pending patent applications in the U.S. and + * in other countries. + * + * U.S. Government Rights - Commercial software. + * Government users are subject to the Sun Microsystems, Inc. standard + * license agreement and applicable provisions of the FAR and its + * supplements. Use is subject to license terms. Sun, Sun + * Microsystems, the Sun logo and Java are trademarks or registered + * trademarks of Sun Microsystems, Inc. in the U.S. and other + * countries. + * + * This product is covered and controlled by U.S. Export Control laws + * and may be subject to the export or import laws in other countries. + * Nuclear, missile, chemical biological weapons or nuclear maritime + * end uses or end users, whether direct or indirect, are strictly + * prohibited. Export or reexport to countries subject to + * U.S. embargo or to entities identified on U.S. export exclusion + * lists, including, but not limited to, the denied persons and + * specially designated nationals lists is strictly prohibited. + */ + +package TransactionalIO.exceptions; + +/** + * Thrown to indicate an error in the use of the transactional memory; + * that is, a violation of the assumptions of use. + */ +public class PanicException extends java.lang.RuntimeException { + + /** + * Creates new PanicException with no detail message. + */ + public PanicException() { + } + + public PanicException(String format, Object ... args) { + super(String.format(format, args)); + } + + /** + * Creates a new PanicException with the specified detail message. + * + * @param msg the detail message. + */ + public PanicException(String msg) { + super(msg); + } + + /** + * Creates an PanicException with the specified cause. + * + * @param cause Throwable that caused PanicException to be thrown + */ + public PanicException(Throwable cause) { + super(cause); + } +} + diff --git a/Robust/Transactions/TransactionalIOSrc/interfaces/BlockAccessModesEnum.java b/Robust/Transactions/TransactionalIOSrc/interfaces/BlockAccessModesEnum.java new file mode 100644 index 00000000..37ce6dd4 --- /dev/null +++ b/Robust/Transactions/TransactionalIOSrc/interfaces/BlockAccessModesEnum.java @@ -0,0 +1,14 @@ +/* + * To change this template, choose Tools | Templates + * and open the template in the editor. + */ + +package TransactionalIO.interfaces; + +/** + * + * @author navid + */ +public enum BlockAccessModesEnum { + READ_WRITE, WRITE, READ +} diff --git a/Robust/Transactions/TransactionalIOSrc/interfaces/ContentionManager.java b/Robust/Transactions/TransactionalIOSrc/interfaces/ContentionManager.java new file mode 100644 index 00000000..af21ee96 --- /dev/null +++ b/Robust/Transactions/TransactionalIOSrc/interfaces/ContentionManager.java @@ -0,0 +1,36 @@ +/* + * To change this template, choose Tools | Templates + * and open the template in the editor. + */ + +package TransactionalIO.interfaces; + +import TransactionalIO.core.BlockDataStructure; +import TransactionalIO.core.ExtendedTransaction; +import TransactionalIO.core.GlobalOffset; +import TransactionalIO.core.TransactionalFile; +import java.util.Vector; + +/** + * + * @author navid + */ + +public interface ContentionManager { + + + public void resolveConflict(ExtendedTransaction me, ExtendedTransaction other, GlobalOffset obj); + public void resolveConflict(ExtendedTransaction me, ExtendedTransaction other, BlockDataStructure obj); + + public void resolveConflict(ExtendedTransaction me, Vector/**/ other, GlobalOffset obj); + public void resolveConflict(ExtendedTransaction me, Vector/**/ other, BlockDataStructure obj); + + public void resolveConflict(ExtendedTransaction me, GlobalOffset obj); + public void resolveConflict(ExtendedTransaction me, BlockDataStructure obj); + + public long getPriority(); + + + public void setPriority(long value); + +} diff --git a/Robust/Transactions/TransactionalIOSrc/interfaces/FileAccessModesEum.java b/Robust/Transactions/TransactionalIOSrc/interfaces/FileAccessModesEum.java new file mode 100644 index 00000000..c956c781 --- /dev/null +++ b/Robust/Transactions/TransactionalIOSrc/interfaces/FileAccessModesEum.java @@ -0,0 +1,17 @@ +/* + * To change this template, choose Tools | Templates + * and open the template in the editor. + */ + +package TransactionalIO.interfaces; + +import java.io.WriteAbortedException; + +/** + * + * @author navid + */ +public enum FileAccessModesEum { + READ_WRITE, APPEND, READ + +} diff --git a/Robust/Transactions/TransactionalIOSrc/interfaces/OffsetDependency.java b/Robust/Transactions/TransactionalIOSrc/interfaces/OffsetDependency.java new file mode 100644 index 00000000..a0f85f1c --- /dev/null +++ b/Robust/Transactions/TransactionalIOSrc/interfaces/OffsetDependency.java @@ -0,0 +1,15 @@ +/* + * To change this template, choose Tools | Templates + * and open the template in the editor. + */ + +package TransactionalIO.interfaces; + +/** + * + * @author navid + */ +public enum OffsetDependency { + NO_ACCESS, NO_DEPENDENCY, WRITE_DEPENDENCY_1, WRITE_DEPENDENCY_2, READ_DEPENDENCY + +} diff --git a/Robust/Transactions/TransactionalIOSrc/interfaces/TransactionStatu.java b/Robust/Transactions/TransactionalIOSrc/interfaces/TransactionStatu.java new file mode 100644 index 00000000..4aeee172 --- /dev/null +++ b/Robust/Transactions/TransactionalIOSrc/interfaces/TransactionStatu.java @@ -0,0 +1,23 @@ +/* + * To change this template, choose Tools | Templates + * and open the template in the editor. + */ + +package TransactionalIO.interfaces; + +import TransactionalIO.core.ExtendedTransaction.Status; + +/** + * + * @author navid + */ +public interface TransactionStatu { + + public void abortThisSystem(); + public TransactionStatu getOtherSystem(); + public void setOtherSystem(TransactionStatu othersystem); + public boolean isActive(); + public boolean isCommitted(); + public boolean isAborted(); + +} diff --git a/Robust/Transactions/TransactionalIOSrc/interfaces/TransactionalProgram.java b/Robust/Transactions/TransactionalIOSrc/interfaces/TransactionalProgram.java new file mode 100644 index 00000000..40a25165 --- /dev/null +++ b/Robust/Transactions/TransactionalIOSrc/interfaces/TransactionalProgram.java @@ -0,0 +1,15 @@ +/* + * To change this template, choose Tools | Templates + * and open the template in the editor. + */ + +package TransactionalIO.interfaces; + +/** + * + * @author navid + */ +public interface TransactionalProgram { + public void execute(); + +} -- 2.34.1