commit: 02b0fcbb539a7d9518e3095ee8aea1ceed105eb7 Author: Patrice Clement <monsieurp <AT> gentoo <DOT> org> AuthorDate: Wed Oct 7 23:08:48 2015 +0000 Commit: Patrice Clement <monsieurp <AT> gentoo <DOT> org> CommitDate: Wed Oct 7 23:09:43 2015 +0000 URL: https://gitweb.gentoo.org/repo/gentoo.git/commit/?id=02b0fcbb
dev-java/colt: Remove dev-java/concurrent-util dependency. Fixes bug 546496. Monkey patch sources and make use of java.concurrent.util packages from the SDK instead. Raise jdk/jre to 1.7. Drop ppc+ppc64. Package-Manager: portage-2.2.20.1 Signed-off-by: Patrice Clement <monsieurp <AT> gentoo.org> dev-java/colt/colt-1.2.0-r3.ebuild | 48 +++++ ...colt-1.2.0-remove-concurrent-util-imports.patch | 210 +++++++++++++++++++++ 2 files changed, 258 insertions(+) diff --git a/dev-java/colt/colt-1.2.0-r3.ebuild b/dev-java/colt/colt-1.2.0-r3.ebuild new file mode 100644 index 0000000..68ae524 --- /dev/null +++ b/dev-java/colt/colt-1.2.0-r3.ebuild @@ -0,0 +1,48 @@ +# Copyright 1999-2015 Gentoo Foundation +# Distributed under the terms of the GNU General Public License v2 +# $Id$ + +EAPI=5 +JAVA_PKG_IUSE="source doc" + +inherit java-pkg-2 java-ant-2 eutils + +DESCRIPTION="A set of Open Source Libraries for High Performance Scientific and Technical Computing in Java" +SRC_URI="http://dsd.lbl.gov/~hoschek/colt-download/releases/${P}.tar.gz"; +HOMEPAGE="http://www-itg.lbl.gov/~hoschek/colt/"; + +LICENSE="colt" +IUSE="" +SLOT="0" +KEYWORDS="~amd64 ~x86" + +DEPEND=">=virtual/jdk-1.7" +RDEPEND=">=virtual/jre-1.7" + +S="${WORKDIR}/${PN}" + +EANT_BUILD_TARGET="javac jar" +JAVA_ANT_REWRITE_CLASSPATH="true" +JAVA_ANT_ENCODING="ISO-8859-1" + +# [0]: I don't know but it must be useful. +# [1]: Monkey patch manually some classes to get rid of the +# oswego.edu.concurrent.util imports. +PATCHES=( + "${FILESDIR}/${P}-benchmark-no-deprecation.patch" + "${FILESDIR}/${P}-remove-concurrent-util-imports.patch" +) + +java_prepare() { + epatch "${PATCHES[@]}" + + find "${S}" -name \*.jar -exec rm -v {} \; || die +} + +src_install() { + java-pkg_dojar "lib/${PN}.jar" + + dohtml README.html || die + use doc && java-pkg_dojavadoc doc/api + use source && java-pkg_dosrc src/* +} diff --git a/dev-java/colt/files/colt-1.2.0-remove-concurrent-util-imports.patch b/dev-java/colt/files/colt-1.2.0-remove-concurrent-util-imports.patch new file mode 100644 index 0000000..2cfbef7 --- /dev/null +++ b/dev-java/colt/files/colt-1.2.0-remove-concurrent-util-imports.patch @@ -0,0 +1,210 @@ +--- src/cern/colt/matrix/linalg/SmpBlas.java.orig 2015-10-07 22:23:44.969486000 +0000 ++++ src/cern/colt/matrix/linalg/SmpBlas.java 2015-10-07 22:29:15.475486000 +0000 +@@ -10,7 +10,8 @@ + + import cern.colt.matrix.DoubleMatrix1D; + import cern.colt.matrix.DoubleMatrix2D; +-import EDU.oswego.cs.dl.util.concurrent.FJTask; ++ ++import java.util.concurrent.ForkJoinTask; + /** + Parallel implementation of the Basic Linear Algebra System for symmetric multi processing boxes. + Currently only a few algorithms are parallelised; the others are fully functional, but run in sequential mode. +@@ -198,7 +199,7 @@ + + // set up concurrent tasks + int span = width/noOfTasks; +- final FJTask[] subTasks = new FJTask[noOfTasks]; ++ final ForkJoinTask[] subTasks = new ForkJoinTask[noOfTasks]; + for (int i=0; i<noOfTasks; i++) { + final int offset = i*span; + if (i==noOfTasks-1) span = width - span*i; // last span may be a bit larger +@@ -217,24 +218,30 @@ + CC = C.viewPart(offset,0,span,p); + } + +- subTasks[i] = new FJTask() { ++ subTasks[i] = new ForkJoinTask() { + public void run() { + seqBlas.dgemm(transposeA,transposeB,alpha,AA,BB,beta,CC); + //System.out.println("Hello "+offset); + } ++ ++ public boolean exec() { return true; } ++ public void setRawResult(Object o) {} ++ public Object getRawResult() {return null;} + }; + } + + // run tasks and wait for completion +- try { +- this.smp.taskGroup.invoke( +- new FJTask() { +- public void run() { +- coInvoke(subTasks); +- } +- } +- ); +- } catch (InterruptedException exc) {} ++ this.smp.taskGroup.invoke( ++ new ForkJoinTask() { ++ public void run() { ++ invokeAll(subTasks); ++ } ++ ++ public boolean exec() { return true; } ++ public void setRawResult(Object o) {} ++ public Object getRawResult() {return null;} ++ } ++ ); + } + public void dgemv(final boolean transposeA, final double alpha, DoubleMatrix2D A, final DoubleMatrix1D x, final double beta, DoubleMatrix1D y) { + /* +@@ -271,7 +278,7 @@ + + // set up concurrent tasks + int span = width/noOfTasks; +- final FJTask[] subTasks = new FJTask[noOfTasks]; ++ final ForkJoinTask[] subTasks = new ForkJoinTask[noOfTasks]; + for (int i=0; i<noOfTasks; i++) { + final int offset = i*span; + if (i==noOfTasks-1) span = width - span*i; // last span may be a bit larger +@@ -280,24 +287,30 @@ + final DoubleMatrix2D AA = A.viewPart(offset,0,span,n); + final DoubleMatrix1D yy = y.viewPart(offset,span); + +- subTasks[i] = new FJTask() { ++ subTasks[i] = new ForkJoinTask() { + public void run() { + seqBlas.dgemv(transposeA,alpha,AA,x,beta,yy); + //System.out.println("Hello "+offset); + } ++ ++ public boolean exec() { return true; } ++ public void setRawResult(Object o) {} ++ public Object getRawResult() {return null;} + }; + } + + // run tasks and wait for completion +- try { +- this.smp.taskGroup.invoke( +- new FJTask() { +- public void run() { +- coInvoke(subTasks); +- } +- } +- ); +- } catch (InterruptedException exc) {} ++ this.smp.taskGroup.invoke( ++ new ForkJoinTask() { ++ public void run() { ++ invokeAll(subTasks); ++ } ++ ++ public boolean exec() { return true; } ++ public void setRawResult(Object o) {} ++ public Object getRawResult() {return null;} ++ } ++ ); + } + public void dger(double alpha, DoubleMatrix1D x, DoubleMatrix1D y, DoubleMatrix2D A) { + seqBlas.dger(alpha,x,y,A); +@@ -369,9 +382,6 @@ + /** + * Prints various snapshot statistics to System.out; Simply delegates to {@link EDU.oswego.cs.dl.util.concurrent.FJTaskRunnerGroup#stats}. + */ +-public void stats() { +- if (this.smp!=null) this.smp.stats(); +-} + private double xsum(DoubleMatrix2D A) { + double[] sums = run(A,true, + new Matrix2DMatrix2DFunction() { +--- src/cern/colt/matrix/linalg/Smp.java.orig 2015-10-07 21:08:19.443486000 +0000 ++++ src/cern/colt/matrix/linalg/Smp.java 2015-10-07 22:28:24.722486000 +0000 +@@ -9,12 +9,13 @@ + package cern.colt.matrix.linalg; + + import cern.colt.matrix.DoubleMatrix2D; +-import EDU.oswego.cs.dl.util.concurrent.FJTask; +-import EDU.oswego.cs.dl.util.concurrent.FJTaskRunnerGroup; ++import java.util.concurrent.ForkJoinTask; ++import java.util.concurrent.ForkJoinPool; ++ + /* + */ + class Smp { +- protected FJTaskRunnerGroup taskGroup; // a very efficient and light weight thread pool ++ protected ForkJoinPool taskGroup; // a very efficient and light weight thread pool + + protected int maxThreads; + /** +@@ -24,41 +25,39 @@ + maxThreads = Math.max(1,maxThreads); + this.maxThreads = maxThreads; + if (maxThreads>1) { +- this.taskGroup = new FJTaskRunnerGroup(maxThreads); ++ this.taskGroup = new ForkJoinPool(maxThreads); + } + else { // avoid parallel overhead + this.taskGroup = null; + } + } +-/** +- * Clean up deamon threads, if necessary. +- */ +-public void finalize() { +- if (this.taskGroup!=null) this.taskGroup.interruptAll(); +-} + protected void run(final DoubleMatrix2D[] blocksA, final DoubleMatrix2D[] blocksB, final double[] results, final Matrix2DMatrix2DFunction function) { +- final FJTask[] subTasks = new FJTask[blocksA.length]; ++ final ForkJoinTask[] subTasks = new ForkJoinTask[blocksA.length]; + for (int i=0; i<blocksA.length; i++) { + final int k = i; +- subTasks[i] = new FJTask() { ++ subTasks[i] = new ForkJoinTask() { + public void run() { + double result = function.apply(blocksA[k],blocksB != null ? blocksB[k] : null); + if (results!=null) results[k] = result; + //System.out.print("."); + } ++ public boolean exec() { return true; } ++ public void setRawResult(Object o) {} ++ public Object getRawResult() {return null;} + }; + } + + // run tasks and wait for completion +- try { +- this.taskGroup.invoke( +- new FJTask() { +- public void run() { +- coInvoke(subTasks); +- } +- } +- ); +- } catch (InterruptedException exc) {} ++ this.taskGroup.invoke( ++ new ForkJoinTask() { ++ public void run() { ++ invokeAll(subTasks); ++ } ++ public boolean exec() { return true; } ++ public void setRawResult(Object o) {} ++ public Object getRawResult() {return null;} ++ } ++ ); + } + protected DoubleMatrix2D[] splitBlockedNN(DoubleMatrix2D A, int threshold, long flops) { + /* +@@ -186,10 +185,4 @@ + } + return blocks; + } +-/** +- * Prints various snapshot statistics to System.out; Simply delegates to {@link EDU.oswego.cs.dl.util.concurrent.FJTaskRunnerGroup#stats}. +- */ +-public void stats() { +- if (this.taskGroup!=null) this.taskGroup.stats(); +-} + }
