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