Robust/Transactions/TransactionalIO/src/TransactionalIO/core/TransactionalFile.java

   1 /*
   2  * To change this template, choose Tools | Templates
   3  * and open the template in the editor.
   4  */
   5 package TransactionalIO.core;
   6
   7
   8
   9 import TransactionalIO.Utilities.Range;
  10 import TransactionalIO.exceptions.AbortedException;
  11 import TransactionalIO.exceptions.PanicException;
  12 import TransactionalIO.benchmarks.benchmark;
  13 import TransactionalIO.core.ExtendedTransaction.Status;
  14 import TransactionalIO.interfaces.BlockAccessModesEnum;
  15 import TransactionalIO.interfaces.OffsetDependency;
  16 import com.sun.org.apache.bcel.internal.generic.IFEQ;
  17 import java.io.File;
  18 import java.io.FileDescriptor;
  19 import java.io.FileNotFoundException;
  20 import java.io.IOException;
  21 import java.io.RandomAccessFile;
  22 import java.nio.ByteBuffer;
  23 import java.util.Collections;
  24 import java.util.Iterator;
  25 import java.util.SortedSet;
  26 import java.util.TreeMap;
  27 import java.util.TreeSet;
  28 import java.util.Vector;
  29 import java.util.concurrent.locks.Lock;
  30 import java.util.concurrent.locks.ReentrantLock;
  31 import java.util.logging.Level;
  32 import java.util.logging.Logger;
  33 import sun.misc.ConditionLock;
  34
  35 /**
  36  *
  37  * @author navid
  38  */
  39
  40
  41 public class TransactionalFile implements Comparable{
  42
  43
  44     private native int nativepread(byte buff[], long offset, int size, FileDescriptor fd);
  45
  46     {
  47         System.load("/home/navid/libkooni.so");
  48     }
  49
  50
  51     public RandomAccessFile file;
  52     private INode inode;
  53     private int sequenceNum = 0;
  54     public static int currenSeqNumforInode = 0;
  55     /*  public AtomicLong commitedoffset;
  56     public AtomicLong commitedfilesize;*/
  57     public boolean to_be_created = false;
  58     public boolean writemode = false;
  59     public boolean appendmode = false;
  60     public ReentrantLock offsetlock;
  61     private GlobalOffset committedoffset;
  62     private GlobalINodeState inodestate ;
  63
  64
  65     public TransactionalFile(String filename, String mode) {
  66
  67
  68         File f = new File(filename);
  69
  70         if ((!(f.exists()))) {
  71             to_be_created = true;
  72             file = null;
  73
  74         } else {
  75
  76             try {
  77
  78                 offsetlock = new ReentrantLock();
  79                 file = new RandomAccessFile(f, mode);
  80             } catch (FileNotFoundException ex) {
  81
  82                 Logger.getLogger(TransactionalFile.class.getName()).log(Level.SEVERE, null, ex);
  83             }
  84
  85         }
  86         inode = TransactionalFileWrapperFactory.getINodefromFileName(filename);
  87         inodestate = TransactionalFileWrapperFactory.createTransactionalFile(inode, filename, mode);
  88
  89
  90         sequenceNum = inodestate.seqNum;
  91         inodestate.seqNum++;
  92
  93
  94
  95
  96
  97         if (mode.equals("rw")) {
  98             writemode = true;
  99         } else if (mode.equals("a")) {
 100             appendmode = true;
 101         }
 102
 103         if (inodestate != null) {
 104             synchronized (inodestate) {
 105                 try {
 106                     //      if (!(to_be_created)) {
 107                     //   } else {
 108                     //       adapter.commitedfilesize.set(0);
 109                     //   }
 110
 111                     if (!appendmode) {
 112                         //commitedoffset.setOffsetnumber(0);
 113                         committedoffset = new GlobalOffset(0);
 114                     } else {
 115                         committedoffset = new GlobalOffset(file.length());
 116                     }
 117
 118                 } catch (IOException ex) {
 119                     Logger.getLogger(TransactionalFile.class.getName()).log(Level.SEVERE, null, ex);
 120                 }
 121             }
 122         }
 123
 124
 125     }
 126
 127     private int invokeNativepread(byte buff[], long offset, int size) {
 128         try {
 129             return nativepread(buff, offset, size, file.getFD());
 130         } catch (IOException ex) {
 131
 132             Logger.getLogger(TransactionalFile.class.getName()).log(Level.SEVERE, null, ex);
 133             return -1;
 134         }
 135
 136     }
 137
 138
 139     public int getSequenceNum() {
 140         return sequenceNum;
 141     }
 142
 143
 144     public GlobalOffset getCommitedoffset() {
 145         return committedoffset;
 146     }
 147
 148     public GlobalINodeState getInodestate() {
 149         return inodestate;
 150     }
 151
 152     /*  public TransactionalFile(Adapter adapter, RandomAccessFile file) {
 153
 154     this.adapter = adapter;
 155     this.file = file;
 156     decriptors = new Vector();
 157     }
 158
 159     public void copyTransactionalFile(TransactionalFile tf){
 160     try {
 161     int tmp = tf.commitedoffset.get();
 162     boolean flag = tf.to_be_created;
 163     FileDescriptor fd = tf.file.getFD();
 164     Adapter ad = new Adapter(tf.adapter);
 165     } catch (IOException ex) {
 166     Logger.getLogger(TransactionalFile.class.getName()).log(Level.SEVERE, null, ex);
 167     }
 168     }*/
 169
 170    /* public BlockDataStructure getBlockDataStructure(int blocknumber) {
 171         synchronized (inodestate.lockmap) {
 172             if (inodestate.lockmap.containsKey(blocknumber)) {
 173
 174                 return ((BlockDataStructure) (inodestate.lockmap.get(Long.valueOf(blocknumber))));
 175             } else {
 176
 177                 BlockDataStructure tmp = new BlockDataStructure(getInode(), blocknumber);
 178                 inodestate.lockmap.put(Integer.valueOf(blocknumber), tmp);
 179                 return tmp;
 180             }
 181         }
 182
 183     }*/
 184
 185
 186
 187     public INode getInode() {
 188         return inode;
 189     }
 190     /* public boolean deleteBlockLock(int blocknumber){
 191     synchronized(adapter.lockmap){
 192     //adapter.lockmap.get(blocknumber)
 193     if (adapter.lockmap.containsKey(blocknumber)){
 194     if (((BlockLock)(adapter.lockmap.get(blocknumber))).referncount == 0){
 195     adapter.lockmap.remove(adapter.lockmap.get(blocknumber));
 196     return true;
 197     }
 198     else
 199     return false;
 200     }
 201     else {
 202     return false;
 203     }
 204     }
 205     }*/
 206     public void close() {
 207         try {
 208             file.close();
 209         } catch (IOException ex) {
 210             Logger.getLogger(TransactionalFile.class.getName()).log(Level.SEVERE, null, ex);
 211         }
 212     }
 213
 214     public long getFilePointer(){
 215
 216         ExtendedTransaction me = Wrapper.getTransaction();
 217         TransactionLocalFileAttributes tmp = null;
 218
 219         if (me == null) {
 220             return non_Transactional_getFilePointer();
 221         }
 222
 223         if (!(me.getGlobaltoLocalMappings().containsKey(this))){
 224
 225                 //if (!(me.getFilesAccesses().containsKey(this.inode))) {
 226                 tmp = new TransactionLocalFileAttributes(0);/*, tf.getInodestate().commitedfilesize.get();*/
 227
 228                  Vector dummy;
 229                  if (me.getAccessedFiles().containsKey(this.getInode())){
 230                     dummy = (Vector) me.getAccessedFiles().get(this.getInode());
 231                  }
 232                  else{
 233                   dummy = new Vector();
 234                   me.getAccessedFiles().put(this.getInode(), dummy);
 235                  }
 236
 237
 238
 239       //      this.msg.put(System.nanoTime(), Thread.currentThread().getName() + " Unlocked the offset lock " + tf.offsetlock + " for file " + tf.getInode() + " form descriptor " + tf.getSequenceNum());
 240                 dummy.add(this);
 241                 me.getGlobaltoLocalMappings().put(this, tmp);
 242                 me.merge_for_writes_done.put(this.getInode(), Boolean.TRUE);
 243
 244               // me.addFile(this);
 245
 246             //me.addFile(this);
 247         }
 248
 249         tmp = (TransactionLocalFileAttributes) me.getGlobaltoLocalMappings().get(this);
 250         if ((tmp.getOffsetdependency() == OffsetDependency.WRITE_DEPENDENCY_1) || (tmp.getOffsetdependency() == OffsetDependency.NO_ACCESS)){
 251              tmp.setOffsetdependency(OffsetDependency.READ_DEPENDENCY);
 252              //System.out.println("sad");
 253              //synchronized(this.committedoffset)
 254              long target;
 255              lockOffset(me);
 256              //{
 257
 258                     if (!(this.committedoffset.getOffsetReaders().contains(me))){
 259                         this.committedoffset.getOffsetReaders().add(me);
 260                         /*synchronized(benchmark.lock){
 261                             benchmark.msg += Thread.currentThread().getName() + " Added to Offset Readers for file " + this.inode + " from descriptor "+ this.sequenceNum +"\n";
 262                         }*/
 263       //                  me.msg.put(System.nanoTime(), Thread.currentThread().getName() + " Added to Offset Readers for file " + this.inode + " from descriptor "+ this.sequenceNum +"\n");
 264                       /*  synchronized(benchmark.lock){
 265                           System.out.println(Thread.currentThread().getName() + " Added to Offset Readers for file " + this.inode + " from descriptor "+ this.sequenceNum +"\n");
 266                         }*/
 267                     }
 268
 269                     tmp.setLocaloffset(tmp.getLocaloffset() + this.committedoffset.getOffsetnumber() - tmp.getCopylocaloffset());
 270                     target = this.committedoffset.getOffsetnumber() - tmp.getCopylocaloffset();
 271
 272
 273              offsetlock.unlock();
 274              //me.getHeldoffsetlocks().remove(offsetlock);
 275
 276              Iterator it;
 277
 278              if ((me.getWriteBuffer().get(inode)) != null)
 279              {
 280
 281                 it = ((Vector) (me.getWriteBuffer().get(inode))).iterator();
 282                 while (it.hasNext()){
 283                     WriteOperations wrp = (WriteOperations) it.next();
 284                     if (wrp.getBelongingto() == tmp && wrp.isUnknownoffset())
 285                         wrp.setUnknownoffset(false);
 286                         /*wrp.getRange().setStart(wrp.getOwnertransactionalFile().committedoffset.getOffsetnumber() - wrp.getBelongingto().getCopylocaloffset() + wrp.getRange().getStart());
 287                         wrp.getRange().setEnd(wrp.getOwnertransactionalFile().committedoffset.getOffsetnumber() - wrp.getBelongingto().getCopylocaloffset() + wrp.getRange().getEnd());*/
 288                         wrp.getRange().setStart(target + wrp.getRange().getStart());
 289                         wrp.getRange().setEnd(target + wrp.getRange().getEnd());
 290                 }
 291              }
 292
 293
 294             //}
 295         }
 296
 297
 298         tmp.setUnknown_inital_offset_for_write(false);
 299
 300      /*   synchronized(benchmark.lock){
 301             benchmark.msg += Thread.currentThread().getName() + " Read the offset value for the file "  + this.inode +" from descriptor " + this.sequenceNum + "\n";
 302         }
 303         me.msg += Thread.currentThread().getName() + " Read the offset value for the file "  + this.inode +" from descriptor " + this.sequenceNum + "\n";*/
 304        /* synchronized(benchmark.lock){
 305             System.out.println("offset " + Thread.currentThread()  + " " + tmp.getLocaloffset());
 306         }*/
 307         return tmp.getLocaloffset();
 308     }
 309
 310     public void seek(long offset) {
 311
 312         if (appendmode) {
 313             throw new PanicException("Cannot seek into a file opened in append mode");
 314         }
 315         ExtendedTransaction me = Wrapper.getTransaction();
 316
 317         if (me == null) {
 318             non_Transactional_Seek(offset);
 319             return;
 320         }
 321
 322         else {
 323          //   if (me.getStatus() != Status.ACTIVE)
 324           //      throw new AbortedException();
 325
 326            TransactionLocalFileAttributes tmp = null;
 327           //tf.offsetlock.lock();
 328
 329           //this.heldoffsetlocks.remove(tf.offsetlock);
 330           //tf.offsetlock.unlock();
 331             if (!(me.getGlobaltoLocalMappings().containsKey(this))){
 332                 //if (!(me.getFilesAccesses().containsKey(this.inode))) {
 333                  tmp = new TransactionLocalFileAttributes(offset);/*, tf.getInodestate().commitedfilesize.get();*/
 334
 335                  Vector dummy;
 336                  if (me.getAccessedFiles().containsKey(this.getInode())){
 337                     dummy = (Vector) me.getAccessedFiles().get(this.getInode());
 338                  }
 339                  else{
 340                   dummy = new Vector();
 341                   me.getAccessedFiles().put(this.getInode(), dummy);
 342                  }
 343
 344
 345
 346       //      this.msg.put(System.nanoTime(), Thread.currentThread().getName() + " Unlocked the offset lock " + tf.offsetlock + " for file " + tf.getInode() + " form descriptor " + tf.getSequenceNum());
 347                 dummy.add(this);
 348                 me.getGlobaltoLocalMappings().put(this, tmp);
 349                 me.merge_for_writes_done.put(this.getInode(), Boolean.TRUE);
 350
 351                 //me.addFile(this);
 352             }
 353             tmp = (TransactionLocalFileAttributes) me.getGlobaltoLocalMappings().get(this);
 354             //tmp = ((TransactionLocalFileAttributes) (me.getFilesAccesses().get(this.getInode())));
 355
 356             if (tmp.getOffsetdependency() == OffsetDependency.NO_ACCESS)
 357                 tmp.setOffsetdependency(OffsetDependency.NO_DEPENDENCY);
 358
 359             else if (tmp.getOffsetdependency() == OffsetDependency.WRITE_DEPENDENCY_1)
 360                 tmp.setOffsetdependency(OffsetDependency.WRITE_DEPENDENCY_2);
 361
 362             tmp.setUnknown_inital_offset_for_write(false);
 363
 364             tmp.setLocaloffset(offset);
 365
 366
 367           /*  synchronized(benchmark.lock){
 368                 System.out.println(tmp.getLocaloffset());
 369             }*/
 370      //       me.msg.put(System.nanoTime(), Thread.currentThread().getName() + " Seeked to the file"  + this.inode +" from descriptor " + this.sequenceNum + "\n");
 371         }
 372     }
 373
 374     public int read(byte[] b) {
 375
 376         if (appendmode) {
 377             throw new PanicException("Cannot seek into a file opened in append mode");
 378         }
 379
 380         boolean firsttime = false;
 381         ExtendedTransaction me = Wrapper.getTransaction();
 382         int size = b.length;
 383         int result = 0;
 384
 385
 386
 387         if (me == null) {  // not a transaction, but any I/O operation even though within a non-transaction is considered a single opertion transactiion
 388             return non_Transactional_Read(b);
 389         }
 390
 391         //if (me.getStatus() != Status.ACTIVE)
 392           //      throw new AbortedException();
 393
 394
 395          if (me.getGlobaltoLocalMappings().containsKey(this)){
 396
 397             /*long target;
 398             Vector locktracker = new Vector();
 399             TreeMap hm = me.getSortedFileAccessMap(me.getAccessedFiles());;
 400             Vector vec = (Vector)hm.get(inode);
 401             Iterator vecit = vec.iterator();
 402             while(vecit.hasNext()){
 403                 TransactionalFile tr = (TransactionalFile)vecit.next();
 404                 TransactionLocalFileAttributes tmp = (TransactionLocalFileAttributes) me.getGlobaltoLocalMappings().get(tr);
 405
 406                 if ((tmp.getOffsetdependency() == OffsetDependency.WRITE_DEPENDENCY_1) || (tmp.offsetdependency == OffsetDependency.NO_ACCESS) || (tmp.getOffsetdependency() == OffsetDependency.WRITE_DEPENDENCY_2)){
 407                     tmp.setUnknown_inital_offset_for_write(false);
 408                     tmp.setOffsetdependency(OffsetDependency.READ_DEPENDENCY);
 409                     tr.lockOffset(me);
 410                     System.out.printtln(Thread.currentThread() + " kiri");
 411                         if (!(tr.committedoffset.getOffsetReaders().contains(me))){
 412                             tr.committedoffset.getOffsetReaders().add(me);
 413                             target = this.committedoffset.getOffsetnumber() - tmp.getCopylocaloffset();
 414                             me.msg.put(System.nanoTime(), Thread.currentThread().getName() + " Added to Offset Readers for file " + this.inode + " from descriptor "+ this.sequenceNum +"\n");
 415                         }
 416                 }
 417             }*/
 418
 419
 420
 421
 422             TransactionLocalFileAttributes tmp = (TransactionLocalFileAttributes) me.getGlobaltoLocalMappings().get(this);
 423             tmp.setUnknown_inital_offset_for_write(false);
 424             if ((tmp.getOffsetdependency() == OffsetDependency.WRITE_DEPENDENCY_1) || (tmp.offsetdependency == OffsetDependency.NO_ACCESS) || (tmp.getOffsetdependency() == OffsetDependency.WRITE_DEPENDENCY_2)){
 425               //System.out.println(Thread.currentThread() + " here");
 426                //synchronized(this.committedoffset){
 427                lockOffset(me);
 428                     if (tmp.getOffsetdependency() != OffsetDependency.WRITE_DEPENDENCY_2){
 429                         tmp.setLocaloffset(tmp.getLocaloffset() + this.committedoffset.getOffsetnumber() - tmp.getCopylocaloffset());
 430                     }
 431
 432                     tmp.setOffsetdependency(OffsetDependency.READ_DEPENDENCY);
 433                     if (!(this.committedoffset.getOffsetReaders().contains(me))){
 434                         this.committedoffset.getOffsetReaders().add(me);
 435                          /*                                  synchronized(benchmark.lock){
 436                                        System.out.println("adding offset " + committedoffset + " " +Thread.currentThread());
 437                                     }*/
 438                        /* synchronized(benchmark.lock){
 439                             benchmark.msg += Thread.currentThread().getName() + " Added to Offset Readers for file " + this.inode + " from descriptor "+ this.sequenceNum +"\n";
 440                         }*/
 441      //                   me.msg.put(System.nanoTime(), Thread.currentThread().getName() + " Added to Offset Readers for file " + this.inode + " from descriptor "+ this.sequenceNum +"\n");
 442                         /*synchronized(benchmark.lock){
 443                           System.out.println(Thread.currentThread().getName() + " Added to Offset Readers for file " + this.inode + " from descriptor "+ this.sequenceNum);
 444                         }*/
 445                     }
 446
 447                offsetlock.unlock();
 448               // me.getHeldoffsetlocks().remove(offsetlock);
 449                 //}
 450             }
 451             Iterator it;
 452             if (me.getWriteBuffer().get(inode) != null)
 453             //if (!(((Vector)(me.getWriteBuffer().get(inode))).isEmpty()))
 454             {
 455                 it = ((Vector) (me.getWriteBuffer().get(inode))).iterator();
 456                 while (it.hasNext()){
 457
 458                       WriteOperations wrp = (WriteOperations) it.next();
 459                       if (wrp.isUnknownoffset()){
 460                         wrp.setUnknownoffset(false);
 461                         //synchronized(wrp.getOwnertransactionalFile().committedoffset){
 462                         wrp.getOwnertransactionalFile().lockOffset(me);
 463
 464                             wrp.getRange().setStart(wrp.getOwnertransactionalFile().committedoffset.getOffsetnumber() - wrp.getBelongingto().getCopylocaloffset() + wrp.getRange().getStart());
 465                             wrp.getRange().setEnd(wrp.getOwnertransactionalFile().committedoffset.getOffsetnumber() - wrp.getBelongingto().getCopylocaloffset() + wrp.getRange().getEnd());
 466                             if ((wrp.getBelongingto().getOffsetdependency() == OffsetDependency.WRITE_DEPENDENCY_1) || (wrp.getBelongingto().offsetdependency == OffsetDependency.NO_ACCESS) || (wrp.getBelongingto().getOffsetdependency() == OffsetDependency.WRITE_DEPENDENCY_2)){
 467                                 wrp.getBelongingto().setOffsetdependency(OffsetDependency.READ_DEPENDENCY);
 468                                 wrp.getBelongingto().setUnknown_inital_offset_for_write(false);
 469                                 if (!(wrp.getOwnertransactionalFile().committedoffset.getOffsetReaders().contains(me)))
 470                                     wrp.getOwnertransactionalFile().committedoffset.getOffsetReaders().add(me);
 471                                 wrp.getBelongingto().setLocaloffset(wrp.getBelongingto().getLocaloffset() + wrp.getOwnertransactionalFile().committedoffset.getOffsetnumber() - wrp.getBelongingto().getCopylocaloffset());
 472                                /* synchronized(benchmark.lock){
 473                                     benchmark.msg += Thread.currentThread().getName() + " Added to Offset Readers for file " + this.inode + " from descriptor "+ wrp.getOwnertransactionalFile().sequenceNum +"\n";
 474                                 }*/
 475                       //          me.msg.put(System.nanoTime(), Thread.currentThread().getName() + " Added to Offset Readers for file " + this.inode + " from descriptor "+ wrp.getOwnertransactionalFile().sequenceNum +"\n");
 476                             }
 477
 478                         // me.getHeldoffsetlocks().remove(wrp.getOwnertransactionalFile().offsetlock);
 479                          wrp.getOwnertransactionalFile().offsetlock.unlock();
 480
 481                          //}
 482
 483
 484
 485                         markAccessedBlocks(me, (int)wrp.getRange().getStart(), (int)(wrp.getRange().getEnd() - wrp.getRange().getStart()), BlockAccessModesEnum.WRITE);
 486 //                        markWriteBlocks((int)wrp.getRange().getStart(), (int)(wrp.getRange().getEnd() - wrp.getRange().getStart()));
 487                       }
 488                 }
 489             }
 490
 491         /*    if (!(me.isWritesmerged())){
 492                //    synchronized(benchmark.lock){
 493                  //   System.out.println("ssssad " + Thread.currentThread() + " " + me.getWriteBuffer());
 494                // }
 495                 mergeWrittenData();
 496             }*/
 497           //  System.out.println("ssssad " + Thread.currentThread() + " " + me.getWriteBuffer());
 498             if ((Boolean)me.merge_for_writes_done.get(inode) == Boolean.FALSE){
 499                // synchronized(benchmark.lock){
 500                 System.out.println("ssssad " + Thread.currentThread() + " " + me.getWriteBuffer());
 501                  mergeWrittenData(me);
 502                //}
 503             }
 504
 505
 506             long loffset = tmp.getLocaloffset();
 507             markAccessedBlocks(me, loffset, size, BlockAccessModesEnum.READ);
 508
 509
 510             Vector writebuffer;
 511             if ((me.getWriteBuffer().get(this.inode)) != null)
 512                 writebuffer = (Vector) (me.getWriteBuffer().get(this.inode));
 513             else {
 514                 writebuffer = new Vector();
 515                 me.getWriteBuffer().put(this.inode, writebuffer);
 516             }
 517             Range readrange = new Range(loffset, loffset + size);
 518             Range writerange = null;
 519             Range[] intersectedrange = new Range[writebuffer.size()];
 520             WriteOperations[] markedwriteop = new WriteOperations[writebuffer.size()];
 521
 522             int counter = 0;
 523
 524
 525
 526
 527             boolean flag = false;
 528             //System.out.println("yani che>??");
 529
 530             it = writebuffer.iterator();
 531             while (it.hasNext()) {
 532
 533                 WriteOperations wrp = (WriteOperations) it.next();
 534                 writerange = wrp.getRange();
 535                 if (writerange.includes(readrange)) {
 536                     markedwriteop[counter] = wrp;
 537                     flag = true;
 538                     break;
 539                 }
 540
 541                 if (writerange.hasIntersection(readrange)) {
 542                     intersectedrange[counter] = readrange.intersection(writerange);
 543                     markedwriteop[counter] = wrp;
 544
 545                     counter++;
 546                 }
 547             }
 548
 549
 550             // for block versioning mechanism
 551             /*if (!(validateBlocksVersions(startblock, targetblock))) { ////check to see if version are still valid
 552
 553                     throw new AbortedException();
 554
 555             }*/
 556             if (flag) {
 557
 558                 result = readFromBuffer(b, tmp, markedwriteop[counter],writerange);
 559
 560              /*   synchronized(benchmark.lock){
 561                     benchmark.msg += Thread.currentThread().getName() + " Read " + this.inode + " from descriptor "+ this.sequenceNum +"\n";
 562                 }*/
 563
 564             //    me.msg.put(System.nanoTime(), Thread.currentThread().getName() + " Read " + this.inode + " from descriptor "+ this.sequenceNum +"\n");
 565                 return result;
 566             }
 567
 568             else{
 569
 570                 if (counter == 0) {
 571                   /*                 synchronized(benchmark.lock){
 572                                        System.out.println("here"  +Thread.currentThread());
 573                     }*/
 574
 575                  //   lockOffset(me);
 576                     result = readFromFile(me, b, tmp);
 577                 }
 578                 else {
 579
 580                     for (int i = 0; i < counter; i++) {
 581
 582
 583                         Byte[] data = markedwriteop[i].getData();
 584                         byte[] copydata = new byte[data.length];
 585
 586                         for (int j = 0; j < data.length; j++) {
 587                             copydata[j] = data[j].byteValue();
 588                         }
 589                         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()));
 590                         result += Math.min(intersectedrange[i].getEnd(), readrange.getEnd()) - intersectedrange[i].getStart();
 591                     }
 592
 593                     Range[] non_intersected_ranges = readrange.minus(intersectedrange, counter);
 594                     Vector occupiedblocks = new Vector();
 595                     Vector heldlocks = new Vector();
 596                     for (int i = 0; i < non_intersected_ranges.length; i++) {
 597                         int st = FileBlockManager.getCurrentFragmentIndexofTheFile(non_intersected_ranges[i].getStart());
 598                         int en = FileBlockManager.getCurrentFragmentIndexofTheFile(non_intersected_ranges[i].getEnd());
 599                         for (int j = st; j <= en; j++) {
 600                             if (!(occupiedblocks.contains(Integer.valueOf(j)))) {
 601                                 occupiedblocks.add(Integer.valueOf(j));
 602                             }
 603                         }
 604                     }
 605
 606
 607
 608                     lockOffset(me);
 609                     me.getHeldoffsetlocks().add(offsetlock);
 610
 611
 612                     for (int k = 0; k < occupiedblocks.size(); k++) {   // locking the block locks
 613
 614                         while (me.getStatus() == Status.ACTIVE) {
 615
 616                             BlockDataStructure block = this.inodestate.getBlockDataStructure((Integer)(occupiedblocks.get(k)));//(BlockDataStructure) tmp.adapter.lockmap.get(Integer.valueOf(k)));
 617
 618                             //synchronized(block){
 619
 620                                // if (block.getLock().readLock().tryLock()) {
 621                             block.getLock().readLock().lock();
 622                                    /* synchronized(benchmark.lock){
 623                                         benchmark.msg += Thread.currentThread().getName() + " Locked The Block Number " + block.getBlocknumber()+ " for file " + this.inode + " from descriptor "+ this.sequenceNum +"\n";
 624                                     }*/
 625            //                         me.msg.put(System.nanoTime(), Thread.currentThread().getName() + " Added The Block Number " + block.getBlocknumber()+ " for file " + this.inode + " from descriptor "+ this.sequenceNum +"\n");
 626                                     //synchronized (block){
 627                                     if (!(block.getReaders().contains(me))){
 628                                        /*     synchronized(benchmark.lock){
 629                                                 benchmark.msg += Thread.currentThread().getName() + " Added to Block Readers for Block Number " + block.getBlocknumber()+ " for file " + this.inode + " from descriptor "+ this.sequenceNum +"\n";
 630                                             }*/
 631               //                          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");
 632                                         block.getReaders().add(me);
 633                                      }
 634                                      me.getHeldblocklocks().add(block.getLock().readLock());
 635                                      //heldlocks.add(block.getLock().readLock());
 636                                     //}
 637                                     break;
 638                               //  }
 639                                 //} else {
 640                                //     me.getContentionmanager().resolveConflict(me, block);
 641                                // }
 642                             //}
 643                         }
 644                        if (me.getStatus() == Status.ABORTED) {
 645                             //unlockLocks(heldlocks);
 646                             //offsetlock.unlock();
 647            //                 me.msg.put(System.nanoTime(), Thread.currentThread().getName() + " Aborted in locking blocks in read\n");
 648                    /*         synchronized(benchmark.lock){
 649                                 benchmark.msg += Thread.currentThread().getName() + " Aborted \n";
 650                             }*/
 651                           //  Thread.currentThread().stop();
 652                             throw new AbortedException();
 653                         }
 654                     }
 655                    /*
 656                         int expvalue = ((Integer) tmp.getBlockversions().get(Integer.valueOf(k))).intValue();
 657                         while (me.getStatus() == Status.ACTIVE) {
 658                             BlockDataStructure block = ((BlockDataStructure) tmp.adapter.lockmap.get(Integer.valueOf(k)));
 659                             if (block.getLock().tryLock()) {
 660                                 heldlocks.add(block.getLock());
 661                                 if (!(block.getVersion().get() == expvalue)) {  // for block versioning mechanism
 662                                         me.abort();
 663                                 }
 664                                 else {
 665                                         break;
 666                                 }
 667                             }
 668                             else {
 669                                     me.getContentionManager().resolveConflict(me, block.getOwner());
 670                             }
 671                         }
 672                       if (me.getStatus() == Status.ABORTED) {
 673                             unlockLocks(heldlocks);
 674                             offsetlock.unlock();
 675                             throw new AbortedException();
 676                         }
 677                     }
 678                    }*/
 679
 680
 681                     for (int i = 0; i < non_intersected_ranges.length; i++) {
 682                         try {
 683                             synchronized(benchmark.lock){
 684                                 System.out.println("read start " + non_intersected_ranges[i].getStart());
 685                             }
 686                             file.seek(non_intersected_ranges[i].getStart());
 687                             int tmpsize = file.read(b, (int) (non_intersected_ranges[i].getStart() - readrange.getStart()), (int) (non_intersected_ranges[i].getEnd() - non_intersected_ranges[i].getStart()));
 688                             result += tmpsize;
 689                         } catch (IOException ex) {
 690
 691                             //unlockLocks(heldlocks);
 692                             //offsetlock.unlock();
 693                             Logger.getLogger(TransactionalFile.class.getName()).log(Level.SEVERE, null, ex);
 694                         }
 695                     }
 696                     me.unlockAllLocks();
 697                     tmp.setLocaloffset(tmp.getLocaloffset() + result);
 698                    // unlockLocks(heldlocks);
 699                    // offsetlock.unlock();
 700                 }
 701                 /*synchronized(benchmark.lock){
 702                     benchmark.msg += Thread.currentThread().getName() + " Read from file " + this.inode + " from descriptor "+ this.sequenceNum +"\n";
 703                 }*/
 704            //     me.msg.put(System.nanoTime(), Thread.currentThread().getName() + " Read from file " + this.inode + " from descriptor "+ this.sequenceNum +"\n");
 705                 return result;
 706             }
 707
 708         } else {           // add to the readers list
 709             System.out.println("form read???");
 710             me.addFile(this);
 711             return read(b);
 712         }
 713
 714     }
 715
 716     public void write(byte[] data) throws IOException {
 717
 718         if (!(writemode)) {
 719             throw new IOException();
 720
 721         }
 722
 723         ExtendedTransaction me = Wrapper.getTransaction();
 724         int size = data.length;
 725
 726
 727         if (me == null) // not a transaction
 728         {
 729
 730             non_Transactional_Write(data);
 731             return;
 732         }
 733
 734         //else if (me.getFilesAccesses().containsKey(this.getInode())) //
 735         //{
 736      //   if (me.getStatus() != Status.ACTIVE)
 737        //         throw new AbortedException();
 738
 739         if (me.getGlobaltoLocalMappings().containsKey(this)) //
 740         {
 741
 742
 743             Byte[] by = new Byte[size];
 744             for (int i = 0; i < size; i++) {
 745                 by[i] = Byte.valueOf(data[i]);
 746             }
 747             TransactionLocalFileAttributes tmp = ((TransactionLocalFileAttributes) (me.getGlobaltoLocalMappings().get(this)));
 748
 749             /*if (appendmode) {
 750                 newwriterange = new Range((((Range) (tm.firstKey())).getStart()), (((Range) (tm.firstKey())).getEnd()) + size);
 751                 Range range = new Range((((Range) (tm.firstKey())).getStart()), (((Range) (tm.firstKey())).getEnd()));
 752                 Byte[] appenddata = new Byte[(int) (newwriterange.getEnd() - newwriterange.getStart())];
 753                 Byte[] tempor = new Byte[(int) (range.getEnd() - range.getStart())];
 754                 System.arraycopy(tempor, 0, appenddata, 0, tempor.length);
 755                 System.arraycopy(by, 0, appenddata, tempor.length, by.length);
 756                 tm.remove(range);
 757                 tm.put(newwriterange, appenddata);
 758                 tmp.setLocaloffset(loffset + size);
 759                 tmp.setFilelength(tmp.getFilelength() + size);
 760
 761                 return;
 762             }*/
 763             Vector dummy;
 764             if (((Vector)(me.getWriteBuffer().get(this.inode))) != null){
 765                 dummy = new Vector((Vector)(me.getWriteBuffer().get(this.inode)));
 766             }
 767             else
 768                 dummy = new Vector();
 769             /* synchronized(benchmark.lock){
 770                     System.out.println(Thread.currentThread() + " gg " + tmp.getLocaloffset() + " " + (tmp.getLocaloffset()+by.length));
 771                 }*/
 772             /*if (!(tmp.isUnknown_inital_offset_for_write())){
 773                 lockOffset(me);
 774                 tmp.setLocaloffset(this.committedoffset.getOffsetnumber());
 775                 offsetlock.unlock();
 776             }*/
 777
 778             dummy.add(new WriteOperations(by, new Range(tmp.getLocaloffset(), tmp.getLocaloffset() + by.length), tmp.isUnknown_inital_offset_for_write(), this, tmp));
 779             me.getWriteBuffer().put(this.inode, dummy);
 780
 781             long loffset = tmp.getLocaloffset();
 782
 783
 784             tmp.setLocaloffset(tmp.getLocaloffset() + by.length);
 785
 786             me.merge_for_writes_done.put(inode, Boolean.FALSE);
 787             //me.setWritesmerged(false);
 788
 789
 790
 791             if (!(tmp.isUnknown_inital_offset_for_write())){
 792                 markAccessedBlocks(me, loffset, size, BlockAccessModesEnum.WRITE);
 793 //                markWriteBlocks(loffset, size);
 794             }
 795             /*{
 796                 int startblock = FileBlockManager.getCurrentFragmentIndexofTheFile(loffset);
 797                     int targetblock = FileBlockManager.getTargetFragmentIndexofTheFile(loffset, size);
 798                     for (int i = startblock; i <= targetblock; i++) {
 799                         if (me.getAccessedBlocks().containsKey(Integer.valueOf(i))) {
 800                             if (((BlockAccessModesEnum) (me.getAccessedBlocks().get(Integer.valueOf(i)))) == BlockAccessModesEnum.READ) {
 801                                 me.getAccessedBlocks().put(Integer.valueOf(i), BlockAccessModesEnum.READ_WRITE);
 802                             }
 803                         } else {
 804                             me.getAccessedBlocks().put(Integer.valueOf(i), BlockAccessModesEnum.WRITE);
 805                         // tmp.getBlockversions().put(Integer.valueOf(i), Integer.valueOf(getBlockDataStructure(i).getVersion().get())); //For Block Versioning Mechanism
 806                         }
 807                     }
 808             }*/
 809
 810             if (tmp.getOffsetdependency() == OffsetDependency.NO_ACCESS)
 811                 tmp.offsetdependency = OffsetDependency.WRITE_DEPENDENCY_1;
 812
 813
 814
 815             /*if ((tmp.access_from_absolute_offset) || !(tmp.relocatablewrite))
 816             {
 817                 int startblock = FileBlockManager.getCurrentFragmentIndexofTheFile(loffset);
 818                 int targetblock = FileBlockManager.getTargetFragmentIndexofTheFile(loffset, size);
 819                 for (int i = startblock; i <= targetblock; i++) {
 820                     if (tmp.getAccesedblocks().containsKey(Integer.valueOf(i))) {
 821                         if (((BlockAccessModesEnum) (tmp.getAccesedblocks().get(Integer.valueOf(i)))) == BlockAccessModesEnum.READ) {
 822                             tmp.getAccesedblocks().put(Integer.valueOf(i), BlockAccessModesEnum.READ_WRITE);
 823                         }
 824                     } else {
 825                         tmp.getAccesedblocks().put(Integer.valueOf(i), BlockAccessModesEnum.WRITE);
 826                     // tmp.getBlockversions().put(Integer.valueOf(i), Integer.valueOf(getBlockDataStructure(i).getVersion().get())); //For Block Versioning Mechanism
 827                     }
 828                 }
 829             }
 830
 831             if (tmp.access_from_absolute_offset){
 832
 833                 mergeWrittenData(tmp.getNon_Speculative_Writtendata(), data, newwriterange);
 834                 tmp.setLocaloffset(loffset + size);
 835                 if (tmp.getLocaloffset() > tmp.getFilelength()) {
 836                     tmp.setFilelength(tmp.getLocaloffset());
 837                 }
 838                 return;
 839             }
 840
 841             else  // for comtimious determingin the accessed block is postpond till commit instant
 842             {
 843                 Byte[] dd = new Byte[size];
 844                 System.arraycopy(by, 0, dd, 0, size);
 845                 if (!(tmp.getSpeculative_Writtendata().isEmpty())){
 846
 847                     Range lastrange = (Range) tmp.getSpeculative_Writtendata().lastKey();
 848                     if (lastrange.getEnd() == newwriterange.getStart()){
 849                         dd = new Byte[(int)(size + lastrange.getEnd() - lastrange.getStart())];
 850                         System.arraycopy(((Byte[])tmp.getSpeculative_Writtendata().get(lastrange)), 0, dd, 0, (int)(lastrange.getEnd() - lastrange.getStart()));
 851                         System.arraycopy(by, 0, dd, (int)(lastrange.getEnd() - lastrange.getStart()), size);
 852                         newwriterange = new Range(lastrange.getStart(), size + lastrange.getEnd());
 853                         tmp.getSpeculative_Writtendata().remove(lastrange);
 854                     }
 855
 856                 }
 857
 858                 tmp.getSpeculative_Writtendata().put(newwriterange, dd);
 859
 860                 tmp.setLocaloffset(loffset + size);
 861                 if (tmp.getLocaloffset() > tmp.getFilelength()) {
 862                     tmp.setFilelength(tmp.getLocaloffset());
 863                 }
 864
 865                 return;
 866             }
 867
 868             */
 869
 870             /*
 871
 872             if (tmp.accessmode == TransactionLocalFileAttributes.MODE.READ)
 873             tmp.accessmode = TransactionLocalFileAttributes.MODE.READ_WRITE;
 874             else if (tmp.accessmode == TransactionLocalFileAttributes.MODE.WRITE)
 875             simpleWritetoBuffer(by, newwriterange, tm);
 876              */
 877            //  me.msg.put(System.nanoTime(), Thread.currentThread().getName() + " Writes to " + this.inode + " from descriptor "+ this.sequenceNum +"\n");
 878
 879         } else {
 880            // System.out.println("form write??");
 881            // me.addFile(this/*, TransactionLocalFileAttributes.MODE.WRITE*/);
 882                //if (!(me.getGlobaltoLocalMappings().containsKey(this))){
 883                 //if (!(me.getFilesAccesses().containsKey(this.inode))) {
 884                 TransactionLocalFileAttributes tmp = new TransactionLocalFileAttributes(0);/*, tf.getInodestate().commitedfilesize.get();*/
 885
 886                  Vector dummy;
 887                  if (me.getAccessedFiles().containsKey(this.getInode())){
 888                     dummy = (Vector) me.getAccessedFiles().get(this.getInode());
 889                  }
 890                  else{
 891                   dummy = new Vector();
 892                   me.getAccessedFiles().put(this.getInode(), dummy);
 893                  }
 894
 895
 896
 897       //      this.msg.put(System.nanoTime(), Thread.currentThread().getName() + " Unlocked the offset lock " + tf.offsetlock + " for file " + tf.getInode() + " form descriptor " + tf.getSequenceNum());
 898                 dummy.add(this);
 899                 me.getGlobaltoLocalMappings().put(this, tmp);
 900                 me.merge_for_writes_done.put(this.getInode(), Boolean.TRUE);
 901
 902             //me.addFile(this);
 903             //}
 904
 905             write(data);
 906         }
 907        /* synchronized(benchmark.lock){
 908             benchmark.msg += Thread.currentThread().getName() + " Writes to " + this.inode + " from descriptor "+ this.sequenceNum +"\n";
 909         }*/
 910
 911
 912     }
 913
 914
 915     private void markAccessedBlocks(ExtendedTransaction me,long loffset, int size, BlockAccessModesEnum mode){
 916
 917         TreeMap map;
 918
 919         if (me.getAccessedBlocks().get(this.getInode()) != null)
 920             map = (TreeMap) me.getAccessedBlocks().get(this.getInode());
 921         else{
 922             map = new TreeMap();
 923             me.getAccessedBlocks().put(this.inode, map);
 924         }
 925         int startblock = FileBlockManager.getCurrentFragmentIndexofTheFile(loffset);
 926         int targetblock = FileBlockManager.getTargetFragmentIndexofTheFile(loffset, size);
 927         for (int i = startblock; i <= targetblock; i++) {
 928             if (map.containsKey(Integer.valueOf(i))){
 929                  if (map.get(Integer.valueOf(i)) != mode){
 930                     map.put(Integer.valueOf(i), BlockAccessModesEnum.READ_WRITE);
 931                  }
 932             }
 933             else{
 934                   map.put(Integer.valueOf(i), mode);
 935             }
 936         }
 937         /*int startblock = FileBlockManager.getCurrentFragmentIndexofTheFile(loffset);
 938         int targetblock = FileBlockManager.getTargetFragmentIndexofTheFile(loffset, size);
 939         for (int i = startblock; i <= targetblock; i++) {
 940             if (me.getAccessedBlocks().containsKey(Integer.valueOf(i))) {
 941                 if (((BlockAccessModesEnum) (me.getAccessedBlocks().get(Integer.valueOf(i)))) == BlockAccessModesEnum.READ) {
 942                     me.getAccessedBlocks().put(Integer.valueOf(i), BlockAccessModesEnum.READ_WRITE);
 943                  }
 944
 945
 946              } else {
 947                     me.getAccessedBlocks().put(Integer.valueOf(i), BlockAccessModesEnum.WRITE);
 948                 // tmp.getBlockversions().put(Integer.valueOf(i), Integer.valueOf(getBlockDataStructure(i).getVersion().get())); //For Block Versioning Mechanism
 949              }
 950         }*/
 951     }
 952
 953 /*    private void markWriteBlocks(long loffset, int size){
 954         ExtendedTransaction me = CustomThread.getTransaction();
 955         SortedSet tt;
 956         if (me.writeBlocks.get(this.inode) != null)
 957             tt = (SortedSet) me.writeBlocks.get(this.inode);
 958         else {
 959             tt = new TreeSet();
 960             me.writeBlocks.put(this.inode, tt);
 961         }
 962
 963         int startblock = FileBlockManager.getCurrentFragmentIndexofTheFile(loffset);
 964         int targetblock = FileBlockManager.getTargetFragmentIndexofTheFile(loffset, size);
 965         for (int i = startblock; i <= targetblock; i++) {
 966             tt.add(Integer.valueOf(i));
 967         }
 968     }*/
 969
 970     private int readFromFile(ExtendedTransaction me, byte[] readdata, TransactionLocalFileAttributes tmp) {
 971
 972
 973         //ExtendedTransaction me = Wrapper.getTransaction();
 974         int st = FileBlockManager.getCurrentFragmentIndexofTheFile(tmp.getLocaloffset());
 975         int end = FileBlockManager.getTargetFragmentIndexofTheFile(tmp.getLocaloffset(), readdata.length);
 976
 977          BlockDataStructure block = null;
 978          boolean locked = false;
 979         for (int k = st; k <= end; k++) {
 980            // int expvalue = ((Integer) tmp.getBlockversions().get(Integer.valueOf(k))).intValue(); // all comments here for versioning mechanism
 981             while (me.getStatus() == Status.ACTIVE) {
 982                 //BlockDataStructure block = ((BlockDataStructure) this.inodestate.lockmap.get(Integer.valueOf(k)));
 983               //  BlockDataStructure block;
 984                 //if (me.getAccessedBlocks().get(inode))
 985                 block = this.inodestate.getBlockDataStructure(Integer.valueOf(k));
 986
 987                 block.getLock().readLock().lock();
 988                       //  me.getHeldblocklocks().add(block.getLock().readLock());
 989                         if (!(block.getReaders().contains(me))){
 990                             block.getReaders().add(me);
 991                         }
 992                         locked = true;
 993              //       if (!(block.getVersion().get() == expvalue)) {
 994              //           me.abort();
 995              //       } else {
 996                      break;
 997              //       }
 998            //     }
 999             /* else {
1000                     me.getContentionmanager().resolveConflict(me, block);
1001                 }*/
1002
1003             }
1004             if (me.getStatus() == Status.ABORTED) {
1005                 int m;
1006                 if (locked){
1007                     m = k+1;
1008                 }
1009                 else
1010                     m = k;
1011                 for (int i=st; i<m; i++){
1012                  /*   System.out.println("///////////////////");
1013                     synchronized(benchmark.lock){
1014                       System.out.println(block.getBlocknumber() + " =? " + i);
1015                     }*/
1016                     block = this.inodestate.getBlockDataStructure(Integer.valueOf(k));
1017                     me.getHeldblocklocks().add(block.getLock().readLock());
1018                   //  System.out.println("///////////////////");
1019                 }
1020
1021                 locked = false;
1022
1023                 throw new AbortedException();
1024             }
1025
1026         }
1027         if (me.getStatus() == Status.ABORTED) {
1028              for (int i=st; i<=end; i++){
1029                     block = this.inodestate.getBlockDataStructure(Integer.valueOf(i));
1030                     me.getHeldblocklocks().add(block.getLock().readLock());
1031              }
1032                 throw new AbortedException();
1033         }
1034
1035         int size = -1;
1036
1037             //ByteBuffer buffer = ByteBuffer.wrap(readdata);
1038             //size = file.getChannel().read(buffer, tmp.getLocaloffset());
1039             size = invokeNativepread(readdata, tmp.getLocaloffset(), readdata.length);
1040
1041            // synchronized(benchmark.lock){
1042            // if (Integer.valueOf(Thread.currentThread().getName().substring(7)) == 0)
1043           /*  for (int i =0; i<readdata.length; i++)
1044                 System.out.println(Thread.currentThread() +  " " + (char)readdata[i]);
1045             }*/
1046            // file.seek(tmp.getLocaloffset());
1047           //  size = file.read(readdata);
1048
1049             tmp.setLocaloffset(tmp.getLocaloffset() + size);
1050
1051             if (size == 0)
1052                 size = -1;
1053
1054
1055          /*   while (it.hasNext()) {
1056
1057                 Lock lock = (Lock) it.next();
1058                 lock.unlock();
1059             }*/
1060         //    me.getHeldblocklocks().clear();
1061     // }
1062
1063         if (me.getStatus() == Status.ABORTED) {
1064                   for (int i=st; i<=end; i++){
1065                     block = this.inodestate.getBlockDataStructure(Integer.valueOf(i));
1066                     me.getHeldblocklocks().add(block.getLock().readLock());
1067              }
1068                 throw new AbortedException();
1069         }
1070         for (int k = st; k <= end; k++) {
1071                     block = this.inodestate.getBlockDataStructure(Integer.valueOf(k));
1072                     block.getLock().readLock().unlock();
1073         }
1074         return size;
1075
1076
1077     }
1078
1079     private int readFromBuffer(byte[] readdata, TransactionLocalFileAttributes tmp, WriteOperations wrp, Range writerange) {
1080         /*synchronized(benchmark.lock){
1081             System.out.println("in read buffer " + Thread.currentThread());
1082         }*/
1083
1084         long loffset = tmp.getLocaloffset();
1085
1086         Byte[] data = (Byte[]) wrp.getData();
1087         byte[] copydata = new byte[data.length];
1088
1089         for (int i = 0; i < data.length; i++) {
1090             copydata[i] = data[i].byteValue();
1091         }
1092         System.arraycopy(copydata, (int) (loffset - writerange.getStart()), readdata, 0, readdata.length);
1093         tmp.setLocaloffset(tmp.getLocaloffset() + readdata.length);
1094         return readdata.length;
1095
1096     }
1097
1098     public void simpleWritetoBuffer(Byte[] data, Range newwriterange, TreeMap tm) {
1099         tm.put(newwriterange, data);
1100     }
1101
1102     public void unlockLocks(Vector heldlocks) {
1103         for (int i = 0; i < heldlocks.size(); i++) {
1104             ((Lock) heldlocks.get(i)).unlock();
1105         }
1106     }
1107
1108
1109 /*    public boolean validateBlocksVersions(int startblock, int targetblock) { // For Block Versioning Mechanism
1110         boolean valid = true;
1111         ExtendedTransaction me = ExtendedTransaction.getTransaction();
1112         TransactionLocalFileAttributes tmp = ((TransactionLocalFileAttributes) (me.getFilesAccesses().get(this.getInode())));
1113         for (int i = startblock; i <= targetblock; i++) {
1114             int expvalue = ((Integer) tmp.getBlockversions().get(Integer.valueOf(i))).intValue();
1115             BlockDataStructure block = ((BlockDataStructure) tmp.adapter.lockmap.get(Integer.valueOf(i)));
1116             if (expvalue != block.getVersion().get()) {
1117                 valid = false;
1118                 break;
1119             }
1120         }
1121
1122         return valid;
1123     }*/
1124
1125
1126
1127     public void setInode(INode inode) {
1128         this.inode = inode;
1129     }
1130
1131     public void lockOffset(ExtendedTransaction me){
1132     //
1133            // System.out.println(Integer.getInteger(me.getStatus().toString()));
1134           //  lo.lockWhen(sequenceNum);
1135             boolean locked = false;
1136             while (me.getStatus() == Status.ACTIVE) {                        //locking the offset
1137                   //synchronized(this.commitedoffset){
1138                //   System.out.println("Trying");
1139               //  try{
1140               //  offsetlock.lockInterruptibly();
1141                     offsetlock.lock();
1142                // }
1143                // catch(InterruptedException e){
1144                  //   System.out.println("dsadsa");
1145                 //}
1146
1147                 //me.getHeldoffsetlocks().add(offsetlock);
1148
1149                locked = true;
1150                break;
1151
1152
1153                //   if (offsetlock.tryLock()) {
1154                         //    synchronized(this.commitedoffset){
1155                         //        this.commitedoffset.setOffsetOwner(me);
1156                       //System.out.println(Thread.currentThread().getName() + " grabbd the lock");
1157                        //     }
1158                    /*   synchronized(benchmark.lock){
1159                         benchmark.msg += Thread.currentThread().getName() + " Locked the offset lock for " + this.inode + " from descriptor "+ this.sequenceNum +"\n";
1160                       }*/
1161                    /*   synchronized(benchmark.lock){
1162                                        System.out.println(Thread.currentThread() + "LOCked the offset lock "  + offsetlock);
1163                       }*/
1164
1165                       //offsetlocks.add(offsetlock);
1166     //                  me.msg.put(System.nanoTime(), Thread.currentThread().getName() + " Locked the offset lock for file " + this.inode + " from descriptor "+ this.sequenceNum +"\n");
1167                       //break;
1168                  // }
1169                        //}
1170                        //me.getContentionmanager().resolveConflict(me, this.commitedoffset);
1171             }
1172
1173           //  if (me.getStatus() != Status.ACTIVE){
1174
1175     //             me.msg.put(System.nanoTime(), Thread.currentThread().getName() + " Aborted  in lock offset\n");
1176                  /*synchronized(benchmark.lock){
1177                     benchmark.msg += Thread.currentThread().getName() + " Aborted \n";
1178                  }*/
1179                  //  CustomThread.getTransaction().setStatus(Status.ACTIVE);
1180                  //  CustomThread.getProgram().execute();
1181 //                 if (offsetlock.isHeldByCurrentThread())
1182                  //if (locked)
1183                  //  offsetlock.unlock();
1184                  //unlockOffsetLocks();
1185                 /* synchronized(benchmark.lock){
1186                      System.out.println("aborting " + committedoffset + " " +Thread.currentThread());
1187                  }*/
1188                  //Thread.currentThread().stop();
1189             if (me.getStatus() != Status.ACTIVE){
1190                if (locked)
1191                     me.getHeldoffsetlocks().add(offsetlock);
1192                 throw new AbortedException();
1193             }
1194
1195            // }
1196     }
1197
1198     public void mergeWrittenData(ExtendedTransaction me/*TreeMap target, byte[] data, Range to_be_merged_data_range*/){
1199
1200             //ExtendedTransaction me = Wrapper.getTransaction();
1201             boolean flag = false;
1202             Vector vec = (Vector) me.getWriteBuffer().get(this.inode);
1203             Range intersectedrange = new Range(0, 0);
1204             Iterator it1 = vec.iterator();
1205             WriteOperations wrp;
1206             WriteOperations wrp2;
1207             Vector toberemoved = new Vector();
1208             while (it1.hasNext()) {
1209                 wrp = (WriteOperations) (it1.next());
1210
1211                 if (toberemoved.contains(wrp)){
1212                     continue;
1213                 }
1214
1215                 Iterator it2 = vec.listIterator();
1216                 while (it2.hasNext()) {
1217                     flag = false;
1218                     wrp2 = (WriteOperations) (it2.next());
1219                     /*if (wrp2.getRange().includes(wrp.getRange())) {
1220                         flag = true;
1221                         intersect = wrp2.getRange().intersection(wrp.getRange());
1222                         break;
1223                     }
1224                     */
1225                     if ((wrp2 == wrp) || toberemoved.contains(wrp2)){
1226                         continue;
1227                     }
1228
1229                     if (wrp.getRange().hasIntersection(wrp2.getRange())) {
1230                         flag = true;
1231                         intersectedrange = wrp2.getRange().intersection(wrp.getRange());
1232                         toberemoved.add(wrp2);
1233                     }
1234
1235
1236                     long startprefix = 0;
1237                     long endsuffix = 0;
1238                     long startsuffix = 0;
1239                     int prefixsize = 0;
1240                     int suffixsize = 0;
1241                     int intermediatesize = 0;
1242                     Byte[] prefixdata = null;
1243                     Byte[] suffixdata = null;
1244                     boolean prefix = false;
1245                     boolean suffix = false;
1246                     if (flag){
1247
1248
1249                         if (wrp.getRange().getStart() < wrp2.getRange().getStart()) {
1250                              prefixdata = new Byte[(int) (wrp2.getRange().getStart() - wrp.getRange().getStart())];
1251                              prefixdata = (Byte[]) (wrp.getData());
1252                              startprefix = wrp.getRange().getStart();
1253                              prefixsize = (int)(intersectedrange.getStart() - startprefix);
1254                              intermediatesize = (int)(intersectedrange.getEnd() -intersectedrange.getStart());
1255                              prefix = true;
1256                         }
1257
1258                         else if (wrp2.getRange().getStart() <= wrp.getRange().getStart()) {
1259                              prefixdata = new Byte[(int) (wrp.getRange().getStart() - wrp2.getRange().getStart())];
1260                              prefixdata = (Byte[]) (wrp2.getData());
1261                              startprefix = wrp2.getRange().getStart();
1262                              prefixsize = (int)(intersectedrange.getStart() - startprefix);
1263                              intermediatesize = (int)(intersectedrange.getEnd() -intersectedrange.getStart());
1264                              prefix = true;
1265                         }
1266
1267                         if (wrp2.getRange().getEnd() >= wrp.getRange().getEnd()) {
1268
1269                              suffixdata = new Byte[(int) (wrp2.getRange().getEnd() - intersectedrange.getEnd())];
1270                              suffixdata = (Byte[]) (wrp2.getData());
1271                              startsuffix = intersectedrange.getEnd() - wrp2.getRange().getStart();
1272                              suffixsize = (int)(wrp2.getRange().getEnd() - intersectedrange.getEnd());
1273                              suffix = true;
1274                              //System.out.println("wrp2 > wrp");
1275
1276                              endsuffix = wrp2.getRange().getEnd();
1277                              //suffixstart = (int) (intersectedrange[i].getEnd() - intersectedrange[i].getStart());
1278                         }
1279
1280                         else if (wrp.getRange().getEnd() > wrp2.getRange().getEnd()) {
1281                              suffixdata = new Byte[(int) (wrp.getRange().getEnd() - intersectedrange.getEnd())];
1282                              suffixdata = (Byte[]) (wrp.getData());
1283                              startsuffix = intersectedrange.getEnd() - wrp.getRange().getStart();
1284                              suffixsize = (int)(wrp.getRange().getEnd() - intersectedrange.getEnd());
1285                             // System.out.println("wrp2 < wrp");
1286                              endsuffix = wrp.getRange().getEnd();
1287                              suffix = true;
1288
1289                         }
1290                     /*   System.out.println("prefix start:" + startprefix);
1291                         System.out.println("suffix end:" + endsuffix);
1292                         System.out.println("suffix start:" + startsuffix);
1293                         System.out.println("intermediate start:" + intermediatetart);
1294
1295                         System.out.println("suffix size:" + suffixsize);*/
1296
1297
1298                         Byte[] data_to_insert;
1299
1300                         if ((prefix) && (suffix)) {
1301                             data_to_insert = new Byte[(int) (endsuffix - startprefix)];
1302                             System.arraycopy(prefixdata, 0, data_to_insert, 0, prefixsize);
1303                             System.arraycopy(wrp2.getData(), (int)(intersectedrange.getStart() - wrp2.getRange().getStart()), data_to_insert, prefixsize, intermediatesize);
1304                             System.arraycopy(suffixdata, (int)startsuffix, data_to_insert, (prefixsize + intermediatesize), suffixsize);
1305                             wrp.setData(data_to_insert);
1306                             wrp.setRange(new Range(startprefix, endsuffix));
1307                         }
1308
1309                     }
1310                 }
1311             }
1312             Iterator it = toberemoved.iterator();
1313             while (it.hasNext())
1314                 vec.remove(it.next());
1315
1316             toberemoved.clear();
1317             Collections.sort(vec);
1318             me.merge_for_writes_done.put(inode, Boolean.TRUE);
1319             //me.setWritesmerged(true);
1320
1321                     /*} else if (prefix) {
1322                         data_to_insert = new Byte[(int) (to_be_merged_data_range.getStart() - start + size)];
1323                         System.arraycopy(prefixdata, 0, data_to_insert, 0, (int) (to_be_merged_data_range.getStart() - start));
1324                         System.arraycopy(by, 0, data_to_insert, (int) (to_be_merged_data_range.getStart() - start), size);
1325                         to_be_merged_data_range.setStart(start);
1326                     } else if (suffix) {
1327                         data_to_insert = new Byte[(int) (to_be_merged_data_range.getEnd() - end + size)];
1328                         System.arraycopy(by, 0, data_to_insert, 0, size);
1329                         System.arraycopy(suffixdata, suffixstart, data_to_insert, size, (int) (end - to_be_merged_data_range.getEnd()));
1330                         to_be_merged_data_range.setEnd(end);
1331                     } else {
1332                         data_to_insert = new Byte[size];
1333                         System.arraycopy(data_to_insert, (int) (to_be_merged_data_range.getStart() - start), by, 0, size);
1334                     }*/
1335                     //target.put(to_be_merged_data_range, data_to_insert);
1336
1337 /*
1338             if (flag) {
1339                 int datasize = (int) (oldwriterange.getEnd() - oldwriterange.getStart());
1340                 Byte[] original = (Byte[]) (wrp.getData());
1341                 byte[] originaldata = new byte[datasize];
1342
1343                 //for (int i = 0; i < data.length; i++) {
1344                 //    originaldata[i] = original[i].byteValue();
1345                // }
1346                 System.arraycopy(data, 0, originaldata, (int) (to_be_merged_data_range.getStart() - oldwriterange.getStart()), size);
1347                 Byte[] to_be_inserted = new Byte[datasize];
1348
1349                 for (int i = 0; i < datasize; i++) {
1350                     to_be_inserted[i] = Byte.valueOf(originaldata[i]);
1351                 }
1352                 target.put(oldwriterange, to_be_inserted);
1353                 return;
1354
1355             } else if (counter == 0) {
1356                 target.put(to_be_merged_data_range, data);
1357                 return;
1358
1359             } else {
1360
1361                 int suffixstart = 0;
1362                 long start = 0;
1363                 long end = 0;
1364                 Byte[] prefixdata = null;
1365                 Byte[] suffixdata = null;
1366                 boolean prefix = false;
1367                 boolean suffix = false;
1368
1369                 for (int i = 0; i < counter; i++) {
1370                     if (markedwriteranges[i].getStart() < to_be_merged_data_range.getStart()) {
1371                         prefixdata = new Byte[(int) (to_be_merged_data_range.getStart() - markedwriteranges[i].getStart())];
1372                         prefixdata = (Byte[]) (target.get(markedwriteranges[i]));
1373                         start = markedwriteranges[i].getStart();
1374                         //newdata = new Byte[size +  newwriterange.getStart() - markedwriteranges[i].getStart()];
1375                         //System.arraycopy(by, 0, newdata, newwriterange.getStart() - markedwriteranges[i].getStart(), size);
1376                         //System.arraycopy(originaldata, 0, newdata, 0, newwriterange.getStart() - markedwriteranges[i].getStart());
1377
1378                         //newwriterange.setStart(markedwriteranges[i].getStart());
1379                         prefix = true;
1380
1381
1382                     } else if (markedwriteranges[i].getEnd() > to_be_merged_data_range.getEnd()) {
1383
1384                         suffixdata = new Byte[(int) (markedwriteranges[i].getStart() - to_be_merged_data_range.getStart())];
1385                         suffixdata = (Byte[]) (target.get(markedwriteranges[i]));
1386                         end = markedwriteranges[i].getEnd();
1387
1388                         //Byte [] originaldata = (Byte [])(tmp.getWrittendata().get(markedwriteranges[i]));
1389                         //newdata = new Byte[size +  newwriterange.getStart() - markedwriteranges[i].getStart()];
1390                         //System.arraycopy(originaldata, 0, newdata, 0, newwriterange.getStart() - markedwriteranges[i].getStart());
1391
1392                         //newwriterange.setStart(markedwriteranges[i].getStart());
1393                         ///newwriterange.setEnd(markedwriteranges[i].getEnd());
1394                         suffix = true;
1395                         suffixstart = (int) (intersectedrange[i].getEnd() - intersectedrange[i].getStart());
1396                     //tm.remove(markedwriteranges[i]);
1397                     }
1398                     target.remove(markedwriteranges[i]);
1399
1400                 }
1401                 Byte[] data_to_insert;
1402
1403                 if ((prefix) && (suffix)) {
1404                     data_to_insert = new Byte[(int) (to_be_merged_data_range.getStart() - start + size - to_be_merged_data_range.getEnd() + end)];
1405                     System.arraycopy(prefixdata, 0, data_to_insert, 0, (int) (to_be_merged_data_range.getStart() - start));
1406                     System.arraycopy(by, 0, data_to_insert, (int) (to_be_merged_data_range.getStart() - start), size);
1407                     System.arraycopy(suffixdata, suffixstart, data_to_insert, (int) (size + to_be_merged_data_range.getStart() - start), (int) (end - to_be_merged_data_range.getEnd()));
1408                     to_be_merged_data_range.setStart(start);
1409                     to_be_merged_data_range.setEnd(end);
1410                 } else if (prefix) {
1411                     data_to_insert = new Byte[(int) (to_be_merged_data_range.getStart() - start + size)];
1412                     System.arraycopy(prefixdata, 0, data_to_insert, 0, (int) (to_be_merged_data_range.getStart() - start));
1413                     System.arraycopy(by, 0, data_to_insert, (int) (to_be_merged_data_range.getStart() - start), size);
1414                     to_be_merged_data_range.setStart(start);
1415                 } else if (suffix) {
1416                     data_to_insert = new Byte[(int) (to_be_merged_data_range.getEnd() - end + size)];
1417                     System.arraycopy(by, 0, data_to_insert, 0, size);
1418                     System.arraycopy(suffixdata, suffixstart, data_to_insert, size, (int) (end - to_be_merged_data_range.getEnd()));
1419                     to_be_merged_data_range.setEnd(end);
1420                 } else {
1421                     data_to_insert = new Byte[size];
1422                     System.arraycopy(data_to_insert, (int) (to_be_merged_data_range.getStart() - start), by, 0, size);
1423                 }
1424                 target.put(to_be_merged_data_range, data_to_insert);
1425                 return;
1426             }*/
1427
1428     }
1429
1430     public void non_Transactional_Write(byte[] data){
1431
1432             Vector heldlocks = new Vector();
1433             boolean flag = true;
1434             offsetlock.lock();
1435             int startblock = FileBlockManager.getCurrentFragmentIndexofTheFile(committedoffset.getOffsetnumber());
1436             int targetblock = FileBlockManager.getTargetFragmentIndexofTheFile(committedoffset.getOffsetnumber(), data.length);
1437             for (int i = startblock; i <= targetblock; i++) {
1438                 BlockDataStructure block =this.inodestate.getBlockDataStructure(i);
1439                 //if (block.getLock().writeLock().tryLock()) {
1440                 block.getLock().writeLock().lock();
1441                     heldlocks.add(block.getLock().writeLock());
1442                 //} else {
1443                 //    unlockLocks(heldlocks);
1444                 //    offsetlock.unlock();
1445                 //    flag = false;
1446                 //    break;
1447                 //}
1448             }
1449
1450             /*if (flag) {
1451                 throw new PanicException("The I/O operation could not be done to contention for the file");
1452             }*/
1453
1454             //else {
1455                 try {
1456
1457                     file.seek(committedoffset.getOffsetnumber());
1458                     file.write(data);
1459
1460                     committedoffset.setOffsetnumber(committedoffset.getOffsetnumber() +data.length);
1461
1462                 } catch (IOException ex) {
1463                     Logger.getLogger(TransactionalFile.class.getName()).log(Level.SEVERE, null, ex);
1464                 } finally {
1465                     unlockLocks(heldlocks);
1466                     offsetlock.unlock();
1467                 }
1468             //}
1469     }
1470
1471     public int non_Transactional_Read(byte[] b){
1472             int size = -1;
1473             Vector heldlocks = new Vector();
1474             boolean flag = true;
1475             offsetlock.lock();
1476             int startblock;
1477             int targetblock;
1478             startblock = FileBlockManager.getCurrentFragmentIndexofTheFile(committedoffset.getOffsetnumber());
1479             targetblock = FileBlockManager.getTargetFragmentIndexofTheFile(committedoffset.getOffsetnumber(), size);
1480          /*   long offset = committedoffset.getOffsetnumber();
1481             committedoffset.setOffsetnumber(committedoffset.getOffsetnumber() +b.length);
1482             if (!(committedoffset.getOffsetReaders().isEmpty())){
1483                 Iterator it2 =  committedoffset.getOffsetReaders().iterator(); // for visible readers strategy
1484                 while ( it2.hasNext())
1485                 {
1486                     ExtendedTransaction tr = (ExtendedTransaction) it2.next();
1487                     tr.abort();
1488                 }
1489                 committedoffset.getOffsetReaders().clear();
1490             }
1491             offsetlock.unlock();*/
1492
1493             for (int i = startblock; i <= targetblock; i++) {
1494                 BlockDataStructure block = this.inodestate.getBlockDataStructure(i);
1495                 //if (block.getLock().readLock().tryLock()) {
1496                 block.getLock().readLock().lock();
1497                     heldlocks.add(block.getLock().readLock());
1498                 /*} else {
1499                     unlockLocks(heldlocks);
1500                     offsetlock.unlock();
1501                     flag = false;
1502                     break;
1503                 }*/
1504             }
1505             /*if (flag) {
1506                 size = -1;
1507             } else {*/
1508
1509
1510
1511          //   try {
1512                 //ByteBuffer buffer = ByteBuffer.wrap(b);
1513                 //System.out.println(committedoffset.getOffsetnumber());
1514                 //size = file.getChannel().read(buffer, offset);
1515                 //file.seek(committedoffset.getOffsetnumber());
1516                // size = file.read(b);
1517                 size = invokeNativepread(b, committedoffset.getOffsetnumber(), b.length);
1518
1519
1520                 committedoffset.setOffsetnumber(committedoffset.getOffsetnumber() +size);
1521                 if (!(committedoffset.getOffsetReaders().isEmpty())){
1522                     Iterator it2 =  committedoffset.getOffsetReaders().iterator(); // for visible readers strategy
1523                     while ( it2.hasNext())
1524                     {
1525                         ExtendedTransaction tr = (ExtendedTransaction) it2.next();
1526                         tr.abort();
1527                 }
1528                 committedoffset.getOffsetReaders().clear();
1529                 }
1530
1531       //      } catch (IOException ex) {
1532          //       Logger.getLogger(TransactionalFile.class.getName()).log(Level.SEVERE, null, ex);
1533         //        size = -1;
1534         //   } finally {
1535                 unlockLocks(heldlocks);
1536                 offsetlock.unlock();
1537                 if (size == 0)
1538                     size = -1;
1539          //   }
1540            // }
1541             return size;
1542
1543     }
1544
1545     public void non_Transactional_Seek(long offset){
1546             offsetlock.lock();
1547             //try {
1548                 //file.seek(offset);
1549                 //synchronized(adapter){
1550                 committedoffset.setOffsetnumber(offset);
1551               //  inodestate.commitedfilesize.set(offset);
1552             //}
1553             //} catch (IOException ex) {
1554              ///   Logger.getLogger(TransactionalFile.class.getName()).log(Level.SEVERE, null, ex);
1555             //} finally {
1556                 offsetlock.unlock();
1557             //}
1558     }
1559
1560     public long non_Transactional_getFilePointer(){
1561             long offset = -1;;
1562             offsetlock.lock();
1563
1564
1565            // try {
1566
1567                 //synchronized(adapter){
1568                 offset = committedoffset.getOffsetnumber();
1569             //}
1570          //   } catch (IOException ex) {
1571          //       Logger.getLogger(TransactionalFile.class.getName()).log(Level.SEVERE, null, ex);
1572           //  } finally {
1573                 offsetlock.unlock();
1574           //  }
1575             return offset;
1576     }
1577
1578     public int compareTo(Object arg0) {
1579         TransactionalFile tf = (TransactionalFile) arg0;
1580         if (this.inode.getNumber() < tf.inode.getNumber())
1581             return -1;
1582         else if (this.inode.getNumber() > tf.inode.getNumber())
1583             return 1;
1584         else {
1585             if (this.sequenceNum < tf.sequenceNum)
1586                 return -1;
1587             else
1588                 return 1;
1589         }
1590     }
1591
1592 }