Robust/Transactions/dstm2src/benchmark/Counter.java

   1 /*
   2  * To change this template, choose Tools | Templates
   3  * and open the template in the editor.
   4  */
   5
   6 package dstm2.benchmark;
   7
   8 import dstm2.Thread;
   9 import dstm2.atomic;
  10 import dstm2.factory.Factory;
  11 import TransactionalIO.benchmarks.benchmark;
  12 import TransactionalIO.core.TransactionalFile;
  13 import dstm2.util.Random;
  14 import java.io.IOException;
  15 import java.util.Iterator;
  16 import java.util.Vector;
  17 import java.util.concurrent.locks.ReentrantLock;
  18 import java.util.logging.Level;
  19 import java.util.logging.Logger;
  20
  21 /**
  22  *
  23  * @author navid
  24  */
  25 public class Counter extends CustomBenchmark {
  26
  27     private static Factory<CountKeeper> factory = Thread.makeFactory(CountKeeper.class);
  28     private CountKeeper word1_occurence;
  29     private CountKeeper word2_occurence;
  30     private CountKeeper word3_occurence;
  31     private CountKeeper word4_occurence;
  32     private CountKeeper word5_occurence;
  33     private CountKeeper word6_occurence;
  34     private CountKeeper word7_occurence;
  35     private CountKeeper word8_occurence;
  36     private CountKeeper word9_occurence;
  37     private CountKeeper word10_occurence;
  38
  39
  40
  41
  42     public void init() {
  43        // for (int i = 0; i< 10; i++)
  44
  45
  46         word1_occurence = factory.create();
  47         word1_occurence.setOccurence(0);
  48
  49         word2_occurence = factory.create();
  50         word2_occurence.setOccurence(0);
  51
  52         word3_occurence = factory.create();
  53         word3_occurence.setOccurence(0);
  54
  55         word4_occurence = factory.create();
  56         word4_occurence.setOccurence(0);
  57
  58         word5_occurence = factory.create();
  59         word5_occurence.setOccurence(0);
  60
  61         word6_occurence = factory.create();
  62         word6_occurence.setOccurence(0);
  63
  64         word7_occurence = factory.create();
  65         word7_occurence.setOccurence(0);
  66
  67         word8_occurence = factory.create();
  68         word8_occurence.setOccurence(0);
  69
  70         word9_occurence = factory.create();
  71         word9_occurence.setOccurence(0);
  72
  73         word10_occurence = factory.create();
  74         word10_occurence.setOccurence(0);
  75
  76     }
  77
  78     public void execute(){
  79                 TransactionalFile f1 = (TransactionalFile)benchmark.m.get("2");
  80                 byte[] data = new byte[1];
  81                 char[] holder = new char[10000];
  82                 char[] word = new char[20];
  83                 boolean flag = false;
  84                 long toseek = Integer.valueOf(Thread.currentThread().getName().substring(7)) * 21169;
  85                 f1.seek(toseek);
  86
  87                 data[0] ='a';
  88                 if (toseek != 0) //////////////// skipt the first word since its been read already
  89                     while (data[0] != '\n'){
  90                         int res;
  91                         res = f1.read(data);
  92                         if (res == -1){
  93                             flag =true;
  94                             break;
  95                         }
  96                     }
  97
  98                 boolean completeword = false;
  99
 100                 int counter = 0;
 101                 while (f1.getFilePointer() < toseek +21169)
 102                 {
 103                     if (flag)
 104                         break;
 105                     data[0] = 'a';
 106                     int i = 0;
 107                     int res;
 108                     //if (completeparag)
 109                     while ((data[0] != '\n' || completeword)){
 110
 111                         if (completeword){
 112                            completeword = false;
 113                            int tmp = processInput(String.valueOf(word,0,counter-1));
 114                            if (tmp != -1){
 115                                 switch(tmp){
 116                                     case 0:
 117                                         word1_occurence.setOccurence(word1_occurence.getOccurence() + 1);
 118                                         break;
 119                                    case 1:
 120                                         word2_occurence.setOccurence(word2_occurence.getOccurence() + 1);
 121                                         break;
 122                                    case 2:
 123                                         word3_occurence.setOccurence(word3_occurence.getOccurence() + 1);
 124                                         break;
 125                                    case 3:
 126                                         word4_occurence.setOccurence(word4_occurence.getOccurence() + 1);
 127                                         break;
 128                                    case 4:
 129                                         word5_occurence.setOccurence(word5_occurence.getOccurence() + 1);
 130                                         break;
 131                                    case 5:
 132                                         word6_occurence.setOccurence(word6_occurence.getOccurence() + 1);
 133                                         break;
 134                                    case 6:
 135                                         word7_occurence.setOccurence(word7_occurence.getOccurence() + 1);
 136                                         break;
 137                                    case 7:
 138                                         word8_occurence.setOccurence(word8_occurence.getOccurence() + 1);
 139                                         break;
 140                                    case 8:
 141                                         word9_occurence.setOccurence(word9_occurence.getOccurence() + 1);
 142                                         break;
 143                                    case 9:
 144                                         word10_occurence.setOccurence(word10_occurence.getOccurence() + 1);
 145                                         break;
 146
 147                                 }
 148                                 //update data structure
 149                                 String tolog = new String();
 150
 151                                 tolog = "-----------------------------------------------------------------";
 152                                 tolog += "Found Word: " + String.valueOf(word,0,counter-1) + "\nAt Offset: ";
 153                                 tolog += f1.getFilePointer() - counter;
 154                                 tolog += "\n";
 155
 156                                 //byte[] towrite0 = new byte[title.length()];
 157                                 //towrite0  = title.getBytes();
 158
 159                                 tolog += String.valueOf(holder,0,i);
 160                                 tolog += "\n";
 161                                 tolog += "-----------------------------------------------------------------";
 162                                 tolog += "\n";
 163
 164                                 byte[] towrite = new byte[tolog.length()];
 165                                 towrite = tolog.getBytes();
 166                                 //towrite = tmpstr.getBytes();
 167
 168
 169                                 try {
 170                                   //  System.out.println("dddddd");
 171
 172                                     ((TransactionalFile) (benchmark.m.get("3"))).write(towrite);
 173                                     //((TransactionalFile) (benchmark.m.get("3"))).write();
 174
 175                                 } catch (IOException ex) {
 176                                     Logger.getLogger(Counter.class.getName()).log(Level.SEVERE, null, ex);
 177                                 }
 178
 179                           }
 180                        }
 181
 182                        if (flag)
 183                             break;
 184
 185                        if (completeword){
 186                            //synchronized(benchmark.lock){
 187                           //  if  (!(Character.isWhitespace(word[counter])))
 188                               //  System.out.println(String.valueOf(word,0,counter-1));
 189                            //}
 190                             holder[i] = (char)data[0];
 191                             i++;
 192
 193                        }
 194                        counter = 0;
 195                        completeword= false;
 196                        data[0] = 'a';
 197                        while(Character.isLetter((char)data[0]))
 198                        {
 199
 200                             res = f1.read(data);
 201                             if (res == -1){
 202                                 flag = true;
 203                                 break;
 204                             }
 205                             word[counter] = (char)data[0];
 206                             counter++;
 207                             if (counter > 1)
 208                                 completeword = true;
 209                             holder[i] = (char)data[0];
 210                             i++;
 211                        }
 212                     }
 213                 }
 214                //return true;
 215         }
 216     protected void execute(String towrite, int indiex_of_object){
 217         switch(indiex_of_object){
 218             case 0:
 219                 word1_occurence.setOccurence(word1_occurence.getOccurence() + 1);
 220                 break;
 221            case 1:
 222                 word2_occurence.setOccurence(word2_occurence.getOccurence() + 1);
 223                 break;
 224            case 2:
 225                 word3_occurence.setOccurence(word3_occurence.getOccurence() + 1);
 226                 break;
 227            case 3:
 228                 word4_occurence.setOccurence(word4_occurence.getOccurence() + 1);
 229                 break;
 230            case 4:
 231                 word5_occurence.setOccurence(word5_occurence.getOccurence() + 1);
 232                 break;
 233            case 5:
 234                 word6_occurence.setOccurence(word6_occurence.getOccurence() + 1);
 235                 break;
 236            case 6:
 237                 word7_occurence.setOccurence(word7_occurence.getOccurence() + 1);
 238                 break;
 239            case 7:
 240                 word8_occurence.setOccurence(word8_occurence.getOccurence() + 1);
 241                 break;
 242            case 8:
 243                 word9_occurence.setOccurence(word9_occurence.getOccurence() + 1);
 244                 break;
 245            case 9:
 246                 word10_occurence.setOccurence(word10_occurence.getOccurence() + 1);
 247                 break;
 248         }
 249
 250
 251         try {
 252             ((TransactionalFile) (benchmark.m.get("3"))).write(towrite.getBytes());
 253
 254         } catch (IOException ex) {
 255             Logger.getLogger(Counter.class.getName()).log(Level.SEVERE, null, ex);
 256         }
 257
 258     }
 259
 260
 261
 262     @atomic public interface CountKeeper{
 263         int getOccurence();
 264         void setOccurence(int value);;
 265     }
 266
 267     private int processInput(String str){
 268
 269         Iterator it = benchmark.m2.keySet().iterator();
 270         while (it.hasNext()){
 271             Integer index = (Integer) it.next();
 272             String pattern = (String)benchmark.m2.get(index);
 273             if (str.equalsIgnoreCase(pattern)){
 274                 return index;
 275             }
 276         }
 277         return -1;
 278     }
 279
 280     public void printResults() {
 281         for (int i =0; i<10; i++)
 282              switch(i){
 283                    case 0:
 284                         System.out.println((String)benchmark.m2.get(Integer.valueOf(i)) + " " + word1_occurence.getOccurence());
 285                         break;
 286                    case 1:
 287                         System.out.println((String)benchmark.m2.get(Integer.valueOf(i)) + " " + word2_occurence.getOccurence());
 288                         break;
 289                    case 2:
 290                         System.out.println((String)benchmark.m2.get(Integer.valueOf(i)) + " " + word3_occurence.getOccurence());
 291                         break;
 292                    case 3:
 293                         System.out.println((String)benchmark.m2.get(Integer.valueOf(i)) + " " + word4_occurence.getOccurence());
 294                         break;
 295                    case 4:
 296                         System.out.println((String)benchmark.m2.get(Integer.valueOf(i)) + " " + word5_occurence.getOccurence());
 297                         break;
 298                    case 5:
 299                         System.out.println((String)benchmark.m2.get(Integer.valueOf(i)) + " " + word6_occurence.getOccurence());
 300                         break;
 301                    case 6:
 302                         System.out.println((String)benchmark.m2.get(Integer.valueOf(i)) + " " + word7_occurence.getOccurence());
 303                         break;
 304                    case 7:
 305                         System.out.println((String)benchmark.m2.get(Integer.valueOf(i)) + " " + word8_occurence.getOccurence());
 306                         break;
 307                    case 8:
 308                         System.out.println((String)benchmark.m2.get(Integer.valueOf(i)) + " " + word9_occurence.getOccurence());
 309                         break;
 310                    case 9:
 311                         System.out.println((String)benchmark.m2.get(Integer.valueOf(i)) + " " + word10_occurence.getOccurence());
 312                         break;
 313              }
 314
 315     }
 316
 317     @Override
 318     protected void execute(Vector arguments) {
 319         String towrite = (String)arguments.get(0);
 320         Integer i = (Integer)arguments.get(1);
 321         int indiex_of_object = i.intValue();
 322          switch(indiex_of_object){
 323             case 0:
 324                 word1_occurence.setOccurence(word1_occurence.getOccurence() + 1);
 325                 break;
 326            case 1:
 327                 word2_occurence.setOccurence(word2_occurence.getOccurence() + 1);
 328                 break;
 329            case 2:
 330                 word3_occurence.setOccurence(word3_occurence.getOccurence() + 1);
 331                 break;
 332            case 3:
 333                 word4_occurence.setOccurence(word4_occurence.getOccurence() + 1);
 334                 break;
 335            case 4:
 336                 word5_occurence.setOccurence(word5_occurence.getOccurence() + 1);
 337                 break;
 338            case 5:
 339                 word6_occurence.setOccurence(word6_occurence.getOccurence() + 1);
 340                 break;
 341            case 6:
 342                 word7_occurence.setOccurence(word7_occurence.getOccurence() + 1);
 343                 break;
 344            case 7:
 345                 word8_occurence.setOccurence(word8_occurence.getOccurence() + 1);
 346                 break;
 347            case 8:
 348                 word9_occurence.setOccurence(word9_occurence.getOccurence() + 1);
 349                 break;
 350            case 9:
 351                 word10_occurence.setOccurence(word10_occurence.getOccurence() + 1);
 352                 break;
 353         }
 354
 355
 356         try {
 357             System.out.println(Thread.currentThread());
 358             ((TransactionalFile) (benchmark.m.get("3"))).write(towrite.getBytes());
 359
 360         } catch (IOException ex) {
 361             Logger.getLogger(Counter.class.getName()).log(Level.SEVERE, null, ex);
 362         }
 363
 364     }
 365
 366
 367
 368 }
 369
 370
 371
 372