Make DeviceId a case class instead of raw Long

Author: Atry

OpenCL/build.sbt

@@ -35,6 +35,6 @@ fork := true
 
 scalacOptions += "-Ypartial-unification"
 
-libraryDependencies += "com.thoughtworks.each" %% "each" % "3.3.1" % Test
+libraryDependencies += "com.thoughtworks.each" %% "each" % "3.3.1"
 
 enablePlugins(Example)

OpenCL/src/main/scala/com/thoughtworks/compute/OpenCL.scala

@@ -18,7 +18,8 @@ import org.lwjgl.system.MemoryStack._
 import org.lwjgl.system.Pointer._
 
 import scala.collection.mutable
-import com.thoughtworks.compute.Memory.{Aux, Box}
+import com.thoughtworks.each.Monadic._
+import com.thoughtworks.compute.Memory.Box
 import com.thoughtworks.compute.OpenCL.{Event, checkErrorCode}, Event.Status
 import org.lwjgl.system.jni.JNINativeInterface
 import org.lwjgl.system._
@@ -86,7 +87,7 @@ object OpenCL {
   private def decodeString(byteBuffer: ByteBuffer): String = memASCII(byteBuffer)
 
   @volatile
-  var defaultLogger: (String, ByteBuffer) => Unit = { (errorInfo: String, data: ByteBuffer) =>
+  var defaultLogger: (String, Option[ByteBuffer]) => Unit = { (errorInfo, data) =>
     // TODO: Add a test for in the case that Context is closed
     Console.err.println(raw"""An OpenCL notify comes out after its corresponding handler is freed
   message: $errorInfo
@@ -105,13 +106,17 @@ object OpenCL {
   private val contextCallback: CLContextCallback = CLContextCallback.create(new CLContextCallbackI {
     def invoke(errInfo: Long, privateInfo: Long, size: Long, userData: Long): Unit = {
       val errorInfo = decodeString(errInfo)
-      val data = memByteBuffer(privateInfo, size.toInt)
+      val dataOption = if (privateInfo != NULL) {
+        Some(memByteBuffer(privateInfo, size.toInt))
+      } else {
+        None
+      }
       memGlobalRefToObject[OpenCL](userData) match {
         case null =>
-          defaultLogger(decodeString(errInfo), memByteBuffer(privateInfo, size.toInt))
+          defaultLogger(decodeString(errInfo), dataOption)
         case opencl =>
           if (size.isValidInt) {
-            opencl.handleOpenCLNotification(decodeString(errInfo), memByteBuffer(privateInfo, size.toInt))
+            opencl.handleOpenCLNotification(decodeString(errInfo), dataOption)
           } else {
             throw new IllegalArgumentException(s"numberOfBytes($size) is too large")
           }
@@ -147,12 +152,13 @@ object OpenCL {
 
     final class ImageFormatNotSupported(message: String = null) extends IllegalStateException(message)
 
-    final class BuildProgramFailure(buildLogs: Map[Long /* device id */, String] = Map.empty)
+    final class BuildProgramFailure[Owner <: Singleton with OpenCL](
+        buildLogs: Map[DeviceId[Owner], String] = Map.empty[DeviceId[Owner], String])
         extends IllegalStateException({
           buildLogs.view
             .map {
               case (deviceId, buildLog) =>
-                f"CL_BUILD_PROGRAM_FAILURE on device 0x$deviceId%X:\n$buildLog"
+                f"CL_BUILD_PROGRAM_FAILURE on device 0x${deviceId.handle}%X:\n$buildLog"
             }
             .mkString("\n")
         })
@@ -784,15 +790,17 @@ object OpenCL {
       result(0)
     }
 
-    def deviceIds: Seq[Long] = {
+    def deviceIds: Seq[DeviceId[Owner]] = {
       val stack = stackPush()
       try {
         val sizeBuffer = stack.mallocPointer(1)
         checkErrorCode(clGetProgramInfo(this.handle, CL_PROGRAM_DEVICES, null: PointerBuffer, sizeBuffer))
         val numberOfDeviceIds = sizeBuffer.get(0).toInt / POINTER_SIZE
         val programDevicesBuffer = stack.mallocPointer(numberOfDeviceIds)
         checkErrorCode(clGetProgramInfo(this.handle, CL_PROGRAM_DEVICES, programDevicesBuffer, sizeBuffer))
-        (0 until numberOfDeviceIds).map(programDevicesBuffer.get)
+        (0 until numberOfDeviceIds).map { i =>
+          DeviceId[Owner](programDevicesBuffer.get(i))
+        }
       } finally {
         stack.close()
       }
@@ -821,16 +829,16 @@ object OpenCL {
       }
     }
 
-    private def buildLogs(deviceIds: Seq[Long]): Map[Long /* device ID */, String] = {
+    private def buildLogs(deviceIds: Seq[DeviceId[Owner]]): Map[DeviceId[Owner], String] = {
       val stack = stackPush()
       try {
         val sizeBuffer = stack.mallocPointer(1)
         deviceIds.view.map { deviceId =>
           checkErrorCode(
-            clGetProgramBuildInfo(this.handle, deviceId, CL_PROGRAM_BUILD_LOG, null: PointerBuffer, sizeBuffer))
+            clGetProgramBuildInfo(this.handle, deviceId.handle, CL_PROGRAM_BUILD_LOG, null: PointerBuffer, sizeBuffer))
           val logBuffer = MemoryUtil.memAlloc(sizeBuffer.get(0).toInt) //stack.malloc()
           try {
-            checkErrorCode(clGetProgramBuildInfo(this.handle, deviceId, CL_PROGRAM_BUILD_LOG, logBuffer, null))
+            checkErrorCode(clGetProgramBuildInfo(this.handle, deviceId.handle, CL_PROGRAM_BUILD_LOG, logBuffer, null))
             (deviceId, decodeString(logBuffer))
           } finally {
             MemoryUtil.memFree(logBuffer)
@@ -841,7 +849,7 @@ object OpenCL {
       }
     }
 
-    private def checkBuildErrorCode(deviceIdsOption: Option[Seq[Long]], errorCode: Int): Unit = {
+    private def checkBuildErrorCode(deviceIdsOption: Option[Seq[DeviceId[Owner]]], errorCode: Int): Unit = {
       errorCode match {
         case CL_BUILD_PROGRAM_FAILURE =>
           val logs = deviceIdsOption match {
@@ -853,10 +861,12 @@ object OpenCL {
       }
     }
 
-    def build(deviceIds: Seq[Long], options: CharSequence = ""): Unit = {
+    def build(deviceIds: Seq[DeviceId[Owner]], options: CharSequence = ""): Unit = {
       val stack = stackPush()
       try {
-        checkBuildErrorCode(Some(deviceIds), clBuildProgram(handle, stack.pointers(deviceIds: _*), options, null, NULL))
+        checkBuildErrorCode(
+          Some(deviceIds),
+          clBuildProgram(handle, stack.pointers(deviceIds.view.map(_.handle): _*), options, null, NULL))
       } finally {
         stack.close()
       }
@@ -920,7 +930,7 @@ object OpenCL {
         commandQueue: CommandQueue,
         deviceBuffer: DeviceBuffer[Element],
         hostBuffer: Destination,
-        preconditionEvents: Event*)(implicit memory: Aux[Element, Destination]): Do[Event] =
+        preconditionEvents: Event*)(implicit memory: Memory.Aux[Element, Destination]): Do[Event] =
       super.enqueueReadBuffer(commandQueue, deviceBuffer, hostBuffer, preconditionEvents: _*).map { event =>
         @tailrec
         def enqueueEvent(): Unit = {
@@ -1010,8 +1020,13 @@ object OpenCL {
 
   trait LogContextNotification extends OpenCL {
 
-    protected def handleOpenCLNotification(errorInfo: String, privateInfo: ByteBuffer): Unit = {
-      Logger.takingImplicit[ByteBuffer](logger.underlying).info(errorInfo)(privateInfo)
+    protected def handleOpenCLNotification(errorInfo: String, privateInfoOption: Option[ByteBuffer]): Unit = {
+      privateInfoOption match {
+        case None =>
+          logger.info(errorInfo)
+        case Some(privateInfo) =>
+          Logger.takingImplicit[ByteBuffer](logger.underlying).info(errorInfo)(privateInfo)
+      }
     }
   }
 
@@ -1184,7 +1199,7 @@ trait OpenCL extends MonadicCloseable[UnitContinuation] with ImplicitsSingleton
     releaseContext >> super.monadicClose
   }
 
-  protected def handleOpenCLNotification(errorInfo: String, privateInfo: ByteBuffer): Unit
+  protected def handleOpenCLNotification(errorInfo: String, privateInfo: Option[ByteBuffer]): Unit
 
   import OpenCL._