ScalaCL lets you run Scala code on GPUs through OpenCL (BSD-licensed).

WORK IN PROGRESS (see ScalaCL if you want something that works, albeit only on Scala 2.9.x).

See slides from ScalaCL + Reified talk @ scala.io 2013.

Features of the new design (v3, rewritten from scratch again!):

• Much better asynchronicity support (now requires OpenCL 1.1), and much better performance in general
• Support for captures of constants and OpenCL arrays
• Support for lazy clones for fast zipping
• Kernels are now fully specialized on static types and generated at compile-time (allows much faster startup and caching at runtime)
• ScalaCL Collections no longer fit in regular Scala Collections, to avoid silent data transfers / conversions when using unaccelerated methods (syntax stays the same, though)
• No more CLRange: expecting compiler to do its job

TODO

• Finish Scalaxy/Reified integration (started under CLFunc / CLFuncUtils)
• Add more tests: DataIO, CodeConversion, scheduling, uniqueness / caching of kernels
• Implement more DataIO[T], support case classes as tuples
• Catch up with compiler plugin:
  • Auto-vectorization
    • 1D works
    • Add 2D
    • add filters
  • Import Scalaxy streams, make them work with scala.reflection.api.Universe
• Plug some v2 runtime code back (filtered array compaction, reduceSymmetric, parallel sums...)
• Benchmarks!
• Wanna help? Ping the NativeLibs4Java mailing-list!

Usage

scalaVersion :="2.11.4"
libraryDependencies +="com.nativelibs4java"%%"scalacl"%"0.3-SNAPSHOT"// Avoid sbt-related macro classpath issues.
fork :=true// Scalaxy/Reified snapshots are published on the Sonatype repository.
resolvers +=Resolver.sonatypeRepo("snapshots")

Examples

The following example currently works:

importscalacl._caseclassMatrix(data: CLArray[Float],
rows: Int,
columns: Int)
(implicitcontext: Context)
{
defthis(rows: Int, columns: Int)
(implicitcontext: Context) =this(newCLArray[Float](rows * columns), rows, columns)
defthis(n: Int)
(implicitcontext: Context) =this(n, n)
defputProduct(a: Matrix, b: Matrix):Unit= {
assert(a.columns == b.rows)
assert(a.rows == rows)
assert(b.columns == columns)
kernel {
// This block will either be converted to an OpenCL kernel or cause compilation errorfor (i <-0 until rows;
j <-0 until columns) {
// c(i, j) = sum(k, a(i, k) * b(k, j))
data(i * columns + j) = (
for (k <-0 until a.columns) yield
a.data(i * a.columns + k) * b.data(k * b.columns + j)
).sum
}
}
}
defputSum(a: Matrix, b: Matrix):Unit= {
assert(a.columns == b.columns && a.columns == columns)
assert(a.rows == b.rows && a.rows == rows)
kernel {
for (i <-0 until rows; j <-0 until columns) {
valoffset= i * columns + j
data(offset) = a.data(offset) + b.data(offset)
}
}
}
}
implicitvalcontext=Context.best
valn=10vala=newMatrix(n)
valb=newMatrix(n)
valout=newMatrix(n)
out.putProduct(a, b)
println(out.data)