001 /* 002 * Copyright (C) 2008-2010 by Holger Arndt 003 * 004 * This file is part of the Universal Java Matrix Package (UJMP). 005 * See the NOTICE file distributed with this work for additional 006 * information regarding copyright ownership and licensing. 007 * 008 * UJMP is free software; you can redistribute it and/or modify 009 * it under the terms of the GNU Lesser General Public License as 010 * published by the Free Software Foundation; either version 2 011 * of the License, or (at your option) any later version. 012 * 013 * UJMP is distributed in the hope that it will be useful, 014 * but WITHOUT ANY WARRANTY; without even the implied warranty of 015 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 016 * GNU Lesser General Public License for more details. 017 * 018 * You should have received a copy of the GNU Lesser General Public 019 * License along with UJMP; if not, write to the 020 * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, 021 * Boston, MA 02110-1301 USA 022 */ 023 024 package org.ujmp.core.benchmark; 025 026 import java.util.LinkedList; 027 import java.util.List; 028 029 import org.ujmp.core.mapmatrix.DefaultMapMatrix; 030 import org.ujmp.core.util.MathUtil; 031 import org.ujmp.core.util.StringUtil; 032 import org.ujmp.core.util.UJMPSettings; 033 034 public class BenchmarkConfig extends DefaultMapMatrix<String, Object> { 035 private static final long serialVersionUID = 2267893158983793396L; 036 037 public static final double NOTAVAILABLE = 0; 038 039 public static final double ERROR = Double.NaN; 040 041 public BenchmarkConfig() { 042 put("name", null); 043 044 put("numberOfThreads", UJMPSettings.getNumberOfThreads()); 045 put("reverse", false); 046 put("shuffle", false); 047 put("gcMemory", true); 048 put("purgeMemory", true); 049 050 put("burnInRuns", 3); 051 put("runs", 25); 052 put("minTrialCount", 1); 053 put("maxTrialCount", 5); 054 put("maxTime", 10000); // maximal time for one operation 055 put("maxStd", 10); // maximal standard deviation results may vary 056 put("maxSize", 10000); // maximal size of a matrix 057 058 put("runTimesScalar", true); 059 put("runPlusMatrix", true); 060 put("runTranspose", true); 061 put("runMtimes", true); 062 put("runInv", true); 063 put("runInvSPD", true); 064 put("runSolveSquare", true); 065 put("runSolveTall", true); 066 put("runSVD", true); 067 put("runEig", true); 068 put("runChol", false); 069 put("runLU", false); 070 put("runQR", false); 071 072 put("runDefaultDenseDoubleMatrix2D", true); 073 put("runArrayDenseDoubleMatrix2D", true); 074 put("runBlockDenseDoubleMatrix2D", true); 075 put("runJBlasDenseDoubleMatrix2D", true); 076 put("runMTJDenseDoubleMatrix2D", true); 077 put("runOjalgoDenseDoubleMatrix2D", true); 078 put("runOrbitalDenseDoubleMatrix2D", false); 079 put("runOwlpackDenseDoubleMatrix2D", false); 080 put("runJScienceDenseDoubleMatrix2D", false); 081 put("runJSciDenseDoubleMatrix2D", false); 082 put("runJMathArrayDenseDoubleMatrix2D", false); 083 put("runJLinAlgDenseDoubleMatrix2D", false); 084 put("runParallelColtDenseDoubleMatrix2D", true); 085 put("runColtDenseDoubleMatrix2D", true); 086 put("runSSTDenseDoubleMatrix2D", false); 087 put("runCommonsMathArrayDenseDoubleMatrix2D", true); 088 put("runCommonsMathBlockDenseDoubleMatrix2D", true); 089 put("runEJMLDenseDoubleMatrix2D", true); 090 put("runJamaDenseDoubleMatrix2D", true); 091 put("runJampackDenseDoubleMatrix2D", false); 092 put("runJMatricesDenseDoubleMatrix2D", false); 093 put("runMantissaDenseDoubleMatrix2D", false); 094 put("runVecMathDenseDoubleMatrix2D", false); 095 096 put("useJBlas", true); 097 put("useBlockMatrixMultiply", true); 098 put("useOjalgo", true); 099 put("useEJML", true); 100 put("useMTJ", true); 101 put("useParallelColt", true); 102 put("useCommonsMath", true); 103 104 put("defaultBlockSize", 100); 105 } 106 107 public List<long[]> getSVDSizes() { 108 return getSquareSizes(); 109 } 110 111 public boolean isRunTimesScalar() { 112 return MathUtil.getBoolean(get("runTimesScalar")); 113 } 114 115 public void setRunTimesScalar(boolean runTimesScalar) { 116 put("runTimesScalar", runTimesScalar); 117 } 118 119 public boolean isRunPlusMatrix() { 120 return MathUtil.getBoolean(get("runPlusMatrix")); 121 } 122 123 public void setRunPlusMatrix(boolean runPlusMatrix) { 124 put("runPlusMatrix", runPlusMatrix); 125 } 126 127 public boolean isRunTranspose() { 128 return MathUtil.getBoolean(get("runTranspose")); 129 } 130 131 public void setRunTranspose(boolean runTranspose) { 132 put("runTranspose", runTranspose); 133 } 134 135 public boolean isRunMtimes() { 136 return MathUtil.getBoolean(get("runMtimes")); 137 } 138 139 public void setRunMtimes(boolean runMtimes) { 140 put("runMtimes", runMtimes); 141 } 142 143 public boolean isRunInv() { 144 return MathUtil.getBoolean(get("runInv")); 145 } 146 147 public boolean isRunInvSPD() { 148 return MathUtil.getBoolean(get("runInvSPD")); 149 } 150 151 public void setRunInv(boolean runInv) { 152 put("runInv", runInv); 153 } 154 155 public void setRunInvSPD(boolean runInv) { 156 put("runInvSPD", runInv); 157 } 158 159 public boolean isRunSolveSquare() { 160 return MathUtil.getBoolean(get("runSolveSquare")); 161 } 162 163 public void setRunSolveSquare(boolean runSolveSquare) { 164 put("runSolveSquare", runSolveSquare); 165 } 166 167 public boolean isRunSolveTall() { 168 return MathUtil.getBoolean(get("runSolveTall")); 169 } 170 171 public void setRunSolveTall(boolean runSolveTall) { 172 put("runSolveTall", runSolveTall); 173 } 174 175 public boolean isRunSVD() { 176 return MathUtil.getBoolean(get("runSVD")); 177 } 178 179 public void setRunSVD(boolean runSVD) { 180 put("runSVD", runSVD); 181 } 182 183 public int getNumberOfThreads() { 184 return MathUtil.getInt(get("numberOfThreads")); 185 } 186 187 public void setNumberOfThreads(int numberOfThreads) { 188 put("numberOfThreads", numberOfThreads); 189 } 190 191 public boolean isRunEig() { 192 return MathUtil.getBoolean(get("runEig")); 193 } 194 195 public void setRunEig(boolean runEig) { 196 put("runEig", runEig); 197 } 198 199 public boolean isRunChol() { 200 return MathUtil.getBoolean(get("runChol")); 201 } 202 203 public void setRunChol(boolean runChol) { 204 put("runChol", runChol); 205 } 206 207 public boolean isRunLU() { 208 return MathUtil.getBoolean(get("runLU")); 209 } 210 211 public void setRunLU(boolean runLU) { 212 put("runLU", runLU); 213 } 214 215 public boolean isRunQR() { 216 return MathUtil.getBoolean(get("runQR")); 217 } 218 219 public void setRunQR(boolean runQR) { 220 put("runQR", runQR); 221 } 222 223 public int getBurnInRuns() { 224 return MathUtil.getInt(get("burnInRuns")); 225 } 226 227 public int getMinTrialCount() { 228 return MathUtil.getInt(get("minTrialCount")); 229 } 230 231 public void setMinTrialCount(int minTrialCount) { 232 put("minTrialCount", minTrialCount); 233 } 234 235 public int getMaxTrialCount() { 236 return MathUtil.getInt(get("maxTrialCount")); 237 } 238 239 public void setMaxTrialCount(int maxTrialCount) { 240 put("maxTrialCount", maxTrialCount); 241 } 242 243 public void setBurnInRuns(int burnInRuns) { 244 put("burnInRuns", burnInRuns); 245 } 246 247 public int getRuns() { 248 return MathUtil.getInt(get("runs")); 249 } 250 251 public void setRuns(int runs) { 252 put("runs", runs); 253 } 254 255 public List<long[]> getSquareSizes() { 256 List<long[]> sizes = new LinkedList<long[]>(); 257 int maxSize = getMaxSize(); 258 sizes.add(new long[] { 2, 2 }); 259 if (maxSize >= 3) { 260 sizes.add(new long[] { 3, 3 }); 261 } 262 if (maxSize >= 4) { 263 sizes.add(new long[] { 4, 4 }); 264 } 265 if (maxSize >= 5) { 266 sizes.add(new long[] { 5, 5 }); 267 } 268 if (maxSize >= 10) { 269 sizes.add(new long[] { 10, 10 }); 270 } 271 if (maxSize >= 20) { 272 sizes.add(new long[] { 20, 20 }); 273 } 274 if (maxSize >= 50) { 275 sizes.add(new long[] { 50, 50 }); 276 } 277 if (maxSize >= 100) { 278 sizes.add(new long[] { 100, 100 }); 279 } 280 if (maxSize >= 200) { 281 sizes.add(new long[] { 200, 200 }); 282 } 283 if (maxSize >= 500) { 284 sizes.add(new long[] { 500, 500 }); 285 } 286 if (maxSize >= 1000) { 287 sizes.add(new long[] { 1000, 1000 }); 288 } 289 if (maxSize >= 2000) { 290 sizes.add(new long[] { 2000, 2000 }); 291 } 292 if (maxSize >= 5000) { 293 sizes.add(new long[] { 5000, 5000 }); 294 } 295 if (maxSize >= 10000) { 296 sizes.add(new long[] { 10000, 10000 }); 297 } 298 return sizes; 299 } 300 301 public List<long[]> getTallSizes() { 302 List<long[]> sizes = new LinkedList<long[]>(); 303 for (long[] s : getSquareSizes()) { 304 s = s.clone(); 305 s[0] *= 2; 306 sizes.add(s); 307 } 308 return sizes; 309 } 310 311 public List<long[]> getTransposeSizes() { 312 return getSquareSizes(); 313 } 314 315 public List<long[]> getTimesSizes() { 316 return getSquareSizes(); 317 } 318 319 public List<long[]> getPlusSizes() { 320 return getSquareSizes(); 321 } 322 323 public List<long[]> getMtimesSizes() { 324 return getSquareSizes(); 325 } 326 327 public List<long[]> getInvSizes() { 328 return getSquareSizes(); 329 } 330 331 public List<long[]> getSolveSquareSizes() { 332 return getSquareSizes(); 333 } 334 335 public List<long[]> getSolveTallSizes() { 336 return getTallSizes(); 337 } 338 339 public List<long[]> getEigSizes() { 340 return getSquareSizes(); 341 } 342 343 public List<long[]> getQRSizes() { 344 return getSquareSizes(); 345 } 346 347 public List<long[]> getLUSizes() { 348 return getSquareSizes(); 349 } 350 351 public List<long[]> getCholSizes() { 352 return getSquareSizes(); 353 } 354 355 public boolean isRunDefaultDenseDoubleMatrix2D() { 356 return MathUtil.getBoolean(get("runDefaultDenseDoubleMatrix2D")); 357 } 358 359 public void setRunDefaultDenseDoubleMatrix2D(boolean runDefaultDenseDoubleMatrix2D) { 360 put("runDefaultDenseDoubleMatrix2D", runDefaultDenseDoubleMatrix2D); 361 } 362 363 public boolean isRunArrayDenseDoubleMatrix2D() { 364 return MathUtil.getBoolean(get("runArrayDenseDoubleMatrix2D")); 365 } 366 367 public boolean isRunBlockDenseDoubleMatrix2D() { 368 return MathUtil.getBoolean(get("runBlockDenseDoubleMatrix2D")); 369 } 370 371 public void setRunArrayDenseDoubleMatrix2D(boolean runArrayDenseDoubleMatrix2D) { 372 put("runArrayDenseDoubleMatrix2D", runArrayDenseDoubleMatrix2D); 373 } 374 375 public void setRunBlockDenseDoubleMatrix2D(boolean runBlockDenseDoubleMatrix2D) { 376 put("runBlockDenseDoubleMatrix2D", runBlockDenseDoubleMatrix2D); 377 } 378 379 public boolean isRunMTJDenseDoubleMatrix2D() { 380 return MathUtil.getBoolean(get("runMTJDenseDoubleMatrix2D")); 381 } 382 383 public void setRunMTJDenseDoubleMatrix2D(boolean runMTJDenseDoubleMatrix2D) { 384 put("runMTJDenseDoubleMatrix2D", runMTJDenseDoubleMatrix2D); 385 } 386 387 public boolean isRunOjalgoDenseDoubleMatrix2D() { 388 return MathUtil.getBoolean(get("runOjalgoDenseDoubleMatrix2D")); 389 } 390 391 public void setRunOjalgoDenseDoubleMatrix2D(boolean runOjalgoDenseDoubleMatrix2D) { 392 put("runOjalgoDenseDoubleMatrix2D", runOjalgoDenseDoubleMatrix2D); 393 } 394 395 public boolean isRunOrbitalDenseDoubleMatrix2D() { 396 return MathUtil.getBoolean(get("runOrbitalDenseDoubleMatrix2D")); 397 } 398 399 public void setRunOrbitalDenseDoubleMatrix2D(boolean runOrbitalDenseDoubleMatrix2D) { 400 put("runOrbitalDenseDoubleMatrix2D", runOrbitalDenseDoubleMatrix2D); 401 } 402 403 public boolean isRunOwlpackDenseDoubleMatrix2D() { 404 return MathUtil.getBoolean(get("runOwlpackDenseDoubleMatrix2D")); 405 } 406 407 public void setRunOwlpackDenseDoubleMatrix2D(boolean runOwlpackDenseDoubleMatrix2D) { 408 put("runOwlpackDenseDoubleMatrix2D", runOwlpackDenseDoubleMatrix2D); 409 } 410 411 public boolean isRunJScienceDenseDoubleMatrix2D() { 412 return MathUtil.getBoolean(get("runJScienceDenseDoubleMatrix2D")); 413 } 414 415 public void setRunJScienceDenseDoubleMatrix2D(boolean runJScienceDenseDoubleMatrix2D) { 416 put("runJScienceDenseDoubleMatrix2D", runJScienceDenseDoubleMatrix2D); 417 } 418 419 public boolean isRunJSciDenseDoubleMatrix2D() { 420 return MathUtil.getBoolean(get("runJSciDenseDoubleMatrix2D")); 421 } 422 423 public void setRunJSciDenseDoubleMatrix2D(boolean runJSciDenseDoubleMatrix2D) { 424 put("runJSciDenseDoubleMatrix2D", runJSciDenseDoubleMatrix2D); 425 } 426 427 public boolean isRunJMathArrayDenseDoubleMatrix2D() { 428 return MathUtil.getBoolean(get("runJMathArrayDenseDoubleMatrix2D")); 429 } 430 431 public void setRunJMathArrayDenseDoubleMatrix2D(boolean runJMathArrayDenseDoubleMatrix2D) { 432 put("runJMathArrayDenseDoubleMatrix2D", runJMathArrayDenseDoubleMatrix2D); 433 } 434 435 public boolean isRunJLinAlgDenseDoubleMatrix2D() { 436 return MathUtil.getBoolean(get("runJLinAlgDenseDoubleMatrix2D")); 437 } 438 439 public void setRunJLinAlgDenseDoubleMatrix2D(boolean runJLinAlgDenseDoubleMatrix2D) { 440 put("runJLinAlgDenseDoubleMatrix2D", runJLinAlgDenseDoubleMatrix2D); 441 } 442 443 public boolean isRunParallelColtDenseDoubleMatrix2D() { 444 return MathUtil.getBoolean(get("runParallelColtDenseDoubleMatrix2D")); 445 } 446 447 public void setRunParallelColtDenseDoubleMatrix2D(boolean runParallelColtDenseDoubleMatrix2D) { 448 put("runParallelColtDenseDoubleMatrix2D", runParallelColtDenseDoubleMatrix2D); 449 } 450 451 public boolean isRunColtDenseDoubleMatrix2D() { 452 return MathUtil.getBoolean(get("runColtDenseDoubleMatrix2D")); 453 } 454 455 public void setRunColtDenseDoubleMatrix2D(boolean runColtDenseDoubleMatrix2D) { 456 put("runColtDenseDoubleMatrix2D", runColtDenseDoubleMatrix2D); 457 } 458 459 public boolean isRunSSTDenseDoubleMatrix2D() { 460 return MathUtil.getBoolean(get("runSSTDenseDoubleMatrix2D")); 461 } 462 463 public void setRunSSTDenseDoubleMatrix2D(boolean runSSTDenseDoubleMatrix2D) { 464 put("runSSTDenseDoubleMatrix2D", runSSTDenseDoubleMatrix2D); 465 } 466 467 public boolean isRunCommonsMathArrayDenseDoubleMatrix2D() { 468 return MathUtil.getBoolean(get("runCommonsMathArrayDenseDoubleMatrix2D")); 469 } 470 471 public void setRunCommonsMathArrayDenseDoubleMatrix2D( 472 boolean runCommonsMathArrayDenseDoubleMatrix2D) { 473 put("runCommonsMathArrayDenseDoubleMatrix2D", runCommonsMathArrayDenseDoubleMatrix2D); 474 } 475 476 public boolean isRunCommonsMathBlockDenseDoubleMatrix2D() { 477 return MathUtil.getBoolean(get("runCommonsMathBlockDenseDoubleMatrix2D")); 478 } 479 480 public void setRunCommonsMathBlockDenseDoubleMatrix2D( 481 boolean runCommonsMathBlockDenseDoubleMatrix2D) { 482 put("runCommonsMathBlockDenseDoubleMatrix2D", runCommonsMathBlockDenseDoubleMatrix2D); 483 } 484 485 public boolean isRunEJMLDenseDoubleMatrix2D() { 486 return MathUtil.getBoolean(get("runEJMLDenseDoubleMatrix2D")); 487 } 488 489 public void setRunEJMLDenseDoubleMatrix2D(boolean runEJMLDenseDoubleMatrix2D) { 490 put("runEJMLDenseDoubleMatrix2D", runEJMLDenseDoubleMatrix2D); 491 } 492 493 public boolean isRunJamaDenseDoubleMatrix2D() { 494 return MathUtil.getBoolean(get("runJamaDenseDoubleMatrix2D")); 495 } 496 497 public void setRunJamaDenseDoubleMatrix2D(boolean runJamaDenseDoubleMatrix2D) { 498 put("runJamaDenseDoubleMatrix2D", runJamaDenseDoubleMatrix2D); 499 } 500 501 public boolean isRunJampackDenseDoubleMatrix2D() { 502 return MathUtil.getBoolean(get("runJampackDenseDoubleMatrix2D")); 503 } 504 505 public void setRunJampackDenseDoubleMatrix2D(boolean runJampackDenseDoubleMatrix2D) { 506 put("runJampackDenseDoubleMatrix2D", runJampackDenseDoubleMatrix2D); 507 } 508 509 public boolean isRunJMatricesDenseDoubleMatrix2D() { 510 return MathUtil.getBoolean(get("runJMatricesDenseDoubleMatrix2D")); 511 } 512 513 public void setRunJMatricesDenseDoubleMatrix2D(boolean runJMatricesDenseDoubleMatrix2D) { 514 put("runJMatricesDenseDoubleMatrix2D", runJMatricesDenseDoubleMatrix2D); 515 } 516 517 public boolean isRunMantissaDenseDoubleMatrix2D() { 518 return MathUtil.getBoolean(get("runMantissaDenseDoubleMatrix2D")); 519 } 520 521 public void setRunMantissaDenseDoubleMatrix2D(boolean runMantissaDenseDoubleMatrix2D) { 522 put("runMantissaDenseDoubleMatrix2D", runMantissaDenseDoubleMatrix2D); 523 } 524 525 public boolean isRunVecMathDenseDoubleMatrix2D() { 526 return MathUtil.getBoolean(get("runVecMathDenseDoubleMatrix2D")); 527 } 528 529 public void setRunVecMathDenseDoubleMatrix2D(boolean runVecMathDenseDoubleMatrix2D) { 530 put("runVecMathDenseDoubleMatrix2D", runVecMathDenseDoubleMatrix2D); 531 } 532 533 public int getMaxTime() { 534 return MathUtil.getInt(get("maxTime")); 535 } 536 537 public int getMaxSize() { 538 return MathUtil.getInt(get("maxSize")); 539 } 540 541 public void setMaxTime(int maxTime) { 542 put("maxTime", maxTime); 543 } 544 545 public void setMaxSize(int maxSize) { 546 put("maxSize", maxSize); 547 } 548 549 public double getMaxStd() { 550 return MathUtil.getDouble(get("maxStd")); 551 } 552 553 public void setMaxStd(double maxStd) { 554 put("maxStd", maxStd); 555 } 556 557 public boolean isGCMemory() { 558 return MathUtil.getBoolean(get("gcMemory")); 559 } 560 561 public void setGCMemory(boolean gcMemory) { 562 put("gcMemory", gcMemory); 563 } 564 565 public boolean isPurgeMemory() { 566 return MathUtil.getBoolean(get("purgeMemory")); 567 } 568 569 public void setPurgeMemory(boolean purgeMemory) { 570 put("purgeMemory", purgeMemory); 571 } 572 573 public boolean isShuffle() { 574 return MathUtil.getBoolean(get("shuffle")); 575 } 576 577 public void setShuffle(boolean shuffle) { 578 put("shuffle", shuffle); 579 } 580 581 public boolean isReverse() { 582 return MathUtil.getBoolean(get("reverse")); 583 } 584 585 public void setReverse(boolean reverse) { 586 put("reverse", reverse); 587 } 588 589 public String getName() { 590 return StringUtil.getString(get("name")); 591 } 592 593 public boolean isRunJBlasDenseDoubleMatrix2D() { 594 return MathUtil.getBoolean(get("runJBlasDenseDoubleMatrix2D")); 595 } 596 597 public void setRunJBlasDenseDoubleMatrix2D(boolean runJBlas) { 598 put("runJBlasDenseDoubleMatrix2D", runJBlas); 599 } 600 601 public void setUseJBlas(boolean use) { 602 put("useJBlas", use); 603 } 604 605 public boolean isUseJBlas() { 606 return MathUtil.getBoolean(get("useJBlas")); 607 } 608 609 public void setUseMTJ(boolean use) { 610 put("useMTJ", use); 611 } 612 613 public boolean isUseMTJ() { 614 return MathUtil.getBoolean(get("useMTJ")); 615 } 616 617 public void setUseOjalgo(boolean use) { 618 put("useOjalgo", use); 619 } 620 621 public boolean isUseOjalgo() { 622 return MathUtil.getBoolean(get("useOjalgo")); 623 } 624 625 public void setUseEJML(boolean use) { 626 put("useEJML", use); 627 } 628 629 public boolean isUseEJML() { 630 return MathUtil.getBoolean(get("useEJML")); 631 } 632 633 public boolean isUseBlockMatrixMultiply() { 634 return MathUtil.getBoolean(get("useBlockMatrixMultiply")); 635 } 636 637 public int getDefaultBlockSize() { 638 return MathUtil.getInt(get("defaultBlockSize")); 639 } 640 641 public void setUseBlockMatrixMultiply(boolean use) { 642 put("useBlockMatrixMultiply", use); 643 } 644 645 public void setDefaultBlockSize(int size) { 646 put("defaultBlockSize", size); 647 } 648 649 public void setUseParallelColt(boolean use) { 650 put("useParallelColt", use); 651 } 652 653 public boolean isUseParallelColt() { 654 return MathUtil.getBoolean(get("useParallelColt")); 655 } 656 657 public void setUseCommonsMath(boolean use) { 658 put("useCommonsMath", use); 659 } 660 661 public boolean isUseCommonsMath() { 662 return MathUtil.getBoolean(get("useCommonsMath")); 663 } 664 665 public void setName(String name) { 666 put("name", name); 667 } 668 }