bundles/org.simantics.db.impl/src/org/simantics/db/impl/PerformanceTests.java

   1 package org.simantics.db.impl;\r
   2 \r
   3 import java.util.ArrayList;\r
   4 import java.util.concurrent.BlockingQueue;\r
   5 import java.util.concurrent.ConcurrentLinkedQueue;\r
   6 import java.util.concurrent.CountDownLatch;\r
   7 import java.util.concurrent.LinkedBlockingQueue;\r
   8 import java.util.concurrent.atomic.AtomicInteger;\r
   9 import java.util.concurrent.locks.ReentrantLock;\r
  10 \r
  11 public class PerformanceTests {\r
  12 \r
  13         \r
  14         public static void collectionTest1() {\r
  15 \r
  16                 final BlockingQueue<Object> queue = new LinkedBlockingQueue<Object>();\r
  17                 final CountDownLatch latch1 = new CountDownLatch(9);\r
  18                 final CountDownLatch latch2 = new CountDownLatch(9);\r
  19                 \r
  20                 class T extends Thread {\r
  21 \r
  22                         @Override\r
  23                         public void run() {\r
  24                                 try {\r
  25                                         latch1.countDown();\r
  26                                         latch1.await();\r
  27                                 } catch (InterruptedException e) {\r
  28                                         e.printStackTrace();\r
  29                                 }\r
  30                                 for(int i=0;i<500000;i++) queue.add(this);\r
  31                                 try {\r
  32                                         latch2.countDown();\r
  33                                         latch2.await();\r
  34                                 } catch (InterruptedException e) {\r
  35                                         e.printStackTrace();\r
  36                                 }\r
  37                         }\r
  38                         \r
  39                 }\r
  40                 \r
  41 \r
  42                 for(int i=0;i<8;i++) new T().start();\r
  43                 \r
  44                 try {\r
  45                         latch1.countDown();\r
  46                         latch1.await();\r
  47                         long start = System.nanoTime();\r
  48                         latch2.countDown();\r
  49                         latch2.await();\r
  50                         long done = System.nanoTime() - start;\r
  51                         System.out.println("took " + 1e-9*done);\r
  52                         start = System.nanoTime();\r
  53                         ArrayList<Object> sink = new ArrayList<Object>();\r
  54                         queue.drainTo(sink);\r
  55                         done = System.nanoTime() - start;\r
  56                         System.out.println("took " + 1e-9*done);\r
  57                         \r
  58                 } catch (InterruptedException e) {\r
  59                         e.printStackTrace();\r
  60                 }\r
  61                 \r
  62         }\r
  63         \r
  64         public static void collectionTest2() {\r
  65 \r
  66                 final ConcurrentLinkedQueue<Object> queue = new ConcurrentLinkedQueue<Object>();\r
  67                 final CountDownLatch latch1 = new CountDownLatch(9);\r
  68                 final CountDownLatch latch2 = new CountDownLatch(9);\r
  69                 \r
  70                 class T extends Thread {\r
  71 \r
  72                         @Override\r
  73                         public void run() {\r
  74                                 try {\r
  75                                         latch1.countDown();\r
  76                                         latch1.await();\r
  77                                 } catch (InterruptedException e) {\r
  78                                         e.printStackTrace();\r
  79                                 }\r
  80                                 for(int i=0;i<500000;i++) queue.add(this);\r
  81                                 try {\r
  82                                         latch2.countDown();\r
  83                                         latch2.await();\r
  84                                 } catch (InterruptedException e) {\r
  85                                         e.printStackTrace();\r
  86                                 }\r
  87                         }\r
  88                         \r
  89                 }\r
  90                 \r
  91 \r
  92                 for(int i=0;i<8;i++) new T().start();\r
  93                 \r
  94                 try {\r
  95                         latch1.countDown();\r
  96                         latch1.await();\r
  97                         long start = System.nanoTime();\r
  98                         latch2.countDown();\r
  99                         latch2.await();\r
 100                         long done = System.nanoTime() - start;\r
 101                         System.out.println("took " + 1e-9*done);\r
 102                         start = System.nanoTime();\r
 103                         ArrayList<Object> sink = new ArrayList<Object>();\r
 104                         for(Object o : queue) sink.add(o);\r
 105                         done = System.nanoTime() - start;\r
 106                         System.out.println("took " + 1e-9*done);\r
 107                         \r
 108                 } catch (InterruptedException e) {\r
 109                         e.printStackTrace();\r
 110                 }\r
 111                 \r
 112         }\r
 113 \r
 114         public static void collectionTest3() {\r
 115 \r
 116                 final ArrayList<Object> queue = new ArrayList<Object>();\r
 117                 final CountDownLatch latch1 = new CountDownLatch(9);\r
 118                 final CountDownLatch latch2 = new CountDownLatch(9);\r
 119                 \r
 120                 class T extends Thread {\r
 121 \r
 122                         @Override\r
 123                         public void run() {\r
 124                                 try {\r
 125                                         latch1.countDown();\r
 126                                         latch1.await();\r
 127                                 } catch (InterruptedException e) {\r
 128                                         e.printStackTrace();\r
 129                                 }\r
 130                                 for(int i=0;i<500000;i++) {\r
 131                                         synchronized(queue) {\r
 132                                                 queue.add(this);\r
 133                                         }\r
 134                                 }\r
 135                                 try {\r
 136                                         latch2.countDown();\r
 137                                         latch2.await();\r
 138                                 } catch (InterruptedException e) {\r
 139                                         e.printStackTrace();\r
 140                                 }\r
 141                         }\r
 142                         \r
 143                 }\r
 144                 \r
 145 \r
 146                 for(int i=0;i<8;i++) new T().start();\r
 147                 \r
 148                 try {\r
 149                         latch1.countDown();\r
 150                         latch1.await();\r
 151                         long start = System.nanoTime();\r
 152                         latch2.countDown();\r
 153                         latch2.await();\r
 154                         long done = System.nanoTime() - start;\r
 155                         System.out.println("took " + 1e-9*done);\r
 156                         start = System.nanoTime();\r
 157                         ArrayList<Object> sink = new ArrayList<Object>();\r
 158                         sink.addAll(queue);\r
 159                         done = System.nanoTime() - start;\r
 160                         System.out.println("took " + 1e-9*done);\r
 161                         \r
 162                 } catch (InterruptedException e) {\r
 163                         e.printStackTrace();\r
 164                 }\r
 165                 \r
 166         }\r
 167 \r
 168         public static void collectionTest4() {\r
 169 \r
 170                 final ArrayList<Object> queue = new ArrayList<Object>();\r
 171                 final CountDownLatch latch1 = new CountDownLatch(9);\r
 172                 final CountDownLatch latch2 = new CountDownLatch(9);\r
 173                 final ReentrantLock lock = new ReentrantLock();\r
 174                 final ReentrantLock lock2 = new ReentrantLock();\r
 175                 \r
 176                 class T extends Thread {\r
 177 \r
 178                         @Override\r
 179                         public void run() {\r
 180                                 try {\r
 181                                         latch1.countDown();\r
 182                                         latch1.await();\r
 183                                 } catch (InterruptedException e) {\r
 184                                         e.printStackTrace();\r
 185                                 }\r
 186                                 for(int i=0;i<500000;i++) {\r
 187                                         lock.lock();\r
 188                                         queue.add(this);\r
 189                                         lock.unlock();\r
 190                                         lock2.tryLock();\r
 191                                 }\r
 192                                 try {\r
 193                                         latch2.countDown();\r
 194                                         latch2.await();\r
 195                                 } catch (InterruptedException e) {\r
 196                                         e.printStackTrace();\r
 197                                 }\r
 198                         }\r
 199                         \r
 200                 }\r
 201                 \r
 202 \r
 203                 for(int i=0;i<8;i++) new T().start();\r
 204                 \r
 205                 try {\r
 206                         latch1.countDown();\r
 207                         latch1.await();\r
 208                         long start = System.nanoTime();\r
 209                         latch2.countDown();\r
 210                         latch2.await();\r
 211                         long done = System.nanoTime() - start;\r
 212                         System.out.println("took " + 1e-9*done);\r
 213                         start = System.nanoTime();\r
 214                         ArrayList<Object> sink = new ArrayList<Object>();\r
 215                         sink.addAll(queue);\r
 216                         done = System.nanoTime() - start;\r
 217                         System.out.println("took " + 1e-9*done);\r
 218                         \r
 219                 } catch (InterruptedException e) {\r
 220                         e.printStackTrace();\r
 221                 }\r
 222                 \r
 223         }\r
 224 \r
 225         public static void counterTest1() {\r
 226 \r
 227                 final CountDownLatch latch1 = new CountDownLatch(9);\r
 228                 final CountDownLatch latch2 = new CountDownLatch(9);\r
 229                 final AtomicInteger integer = new AtomicInteger();\r
 230                 \r
 231                 class T extends Thread {\r
 232 \r
 233                         @Override\r
 234                         public void run() {\r
 235                                 try {\r
 236                                         latch1.countDown();\r
 237                                         latch1.await();\r
 238                                 } catch (InterruptedException e) {\r
 239                                         e.printStackTrace();\r
 240                                 }\r
 241                                 for(int i=0;i<500000;i++) {\r
 242                                         integer.incrementAndGet();\r
 243                                 }\r
 244                                 try {\r
 245                                         latch2.countDown();\r
 246                                         latch2.await();\r
 247                                 } catch (InterruptedException e) {\r
 248                                         e.printStackTrace();\r
 249                                 }\r
 250                         }\r
 251                         \r
 252                 }\r
 253                 \r
 254 \r
 255                 for(int i=0;i<8;i++) new T().start();\r
 256                 \r
 257                 try {\r
 258                         latch1.countDown();\r
 259                         latch1.await();\r
 260                         long start = System.nanoTime();\r
 261                         latch2.countDown();\r
 262                         latch2.await();\r
 263                         long done = System.nanoTime() - start;\r
 264                         System.out.println("took " + 1e-9*done);\r
 265                         \r
 266                 } catch (InterruptedException e) {\r
 267                         e.printStackTrace();\r
 268                 }\r
 269                 \r
 270         }\r
 271 \r
 272         static int counter = 0;\r
 273         \r
 274         public static void counterTest2() {\r
 275 \r
 276                 final CountDownLatch latch1 = new CountDownLatch(9);\r
 277                 final CountDownLatch latch2 = new CountDownLatch(9);\r
 278                 final ReentrantLock lock = new ReentrantLock();\r
 279                 \r
 280                 class T extends Thread {\r
 281 \r
 282                         @Override\r
 283                         public void run() {\r
 284                                 try {\r
 285                                         latch1.countDown();\r
 286                                         latch1.await();\r
 287                                 } catch (InterruptedException e) {\r
 288                                         e.printStackTrace();\r
 289                                 }\r
 290                                 for(int i=0;i<500000;i++) {\r
 291                                         lock.lock();\r
 292                                         counter++;\r
 293                                         lock.unlock();\r
 294                                 }\r
 295                                 try {\r
 296                                         latch2.countDown();\r
 297                                         latch2.await();\r
 298                                 } catch (InterruptedException e) {\r
 299                                         e.printStackTrace();\r
 300                                 }\r
 301                         }\r
 302                         \r
 303                 }\r
 304                 \r
 305 \r
 306                 for(int i=0;i<8;i++) new T().start();\r
 307                 \r
 308                 try {\r
 309                         latch1.countDown();\r
 310                         latch1.await();\r
 311                         long start = System.nanoTime();\r
 312                         latch2.countDown();\r
 313                         latch2.await();\r
 314                         long done = System.nanoTime() - start;\r
 315                         System.out.println("took " + 1e-9*done);\r
 316                         \r
 317                 } catch (InterruptedException e) {\r
 318                         e.printStackTrace();\r
 319                 }\r
 320                 \r
 321         }\r
 322 \r
 323         public static void counterTest3() {\r
 324 \r
 325                 final CountDownLatch latch1 = new CountDownLatch(9);\r
 326                 final CountDownLatch latch2 = new CountDownLatch(9);\r
 327                 //final ReentrantLock lock = new ReentrantLock();\r
 328                 \r
 329                 class T extends Thread {\r
 330 \r
 331                         @Override\r
 332                         public void run() {\r
 333                                 try {\r
 334                                         latch1.countDown();\r
 335                                         latch1.await();\r
 336                                 } catch (InterruptedException e) {\r
 337                                         e.printStackTrace();\r
 338                                 }\r
 339                                 for(int i=0;i<500000;i++) {\r
 340                                         //lock.lock();\r
 341                                         counter++;\r
 342                                         //lock.unlock();\r
 343                                 }\r
 344                                 try {\r
 345                                         latch2.countDown();\r
 346                                         latch2.await();\r
 347                                 } catch (InterruptedException e) {\r
 348                                         e.printStackTrace();\r
 349                                 }\r
 350                         }\r
 351                         \r
 352                 }\r
 353                 \r
 354 \r
 355                 for(int i=0;i<8;i++) new T().start();\r
 356                 \r
 357                 try {\r
 358                         latch1.countDown();\r
 359                         latch1.await();\r
 360                         long start = System.nanoTime();\r
 361                         latch2.countDown();\r
 362                         latch2.await();\r
 363                         long done = System.nanoTime() - start;\r
 364                         System.out.println("took " + 1e-9*done);\r
 365                         \r
 366                 } catch (InterruptedException e) {\r
 367                         e.printStackTrace();\r
 368                 }\r
 369                 \r
 370         }\r
 371         \r
 372         public static void main(String[] args) {\r
 373 //              collectionTest1();\r
 374 //              collectionTest2();\r
 375 //              collectionTest3();\r
 376 //              collectionTest4();\r
 377                 counterTest3();\r
 378         }\r
 379         \r
 380 }\r