) new JsonSlurper().parseText(json);
+ return postProcess(new JsonSlurper().parseText(json));
}
/** Dumps the given exception, including stack trace, to a string. */
@@ -56,4 +61,129 @@ public static String stackTrace(Throwable t) {
t.printStackTrace(new PrintWriter(sw));
return sw.toString();
}
+
+
+ // == serialization =======================================================
+
+ /*
+ SharedMemory is represented in JSON as
+ {
+ appose_type:shm
+ name:psm_4812f794
+ size:16384
+ }
+
+ where
+ "name" is the unique name of the shared memory segment
+ "size" is the size in bytes.
+ (as required for python shared_memory.SharedMemory constructor)
+
+
+ NDArray is represented in JSON as
+ {
+ appose_type:ndarray
+ shm:{...}
+ dtype:float32
+ shape:[2, 3, 4]
+ }
+
+ where
+ "shm" is the representation of the underlying shared memory segment (as described above)
+ "dtype" is the data type of the array elements
+ "shape" is the array dimensions in C-Order
+ */
+
+ /**
+ * Helper to create a {@link JsonGenerator.Converter}.
+ *
+ * The converter objects of a specified class {@code clz} into a {@code
+ * Map}. The given {@code appose_type} string is put into
+ * the map with key {@code "appose_type"}. The map and value to be converted
+ * are passed to the given {@code BiConsumer} which should serialize the
+ * value into the map somehow.
+ *
+ * @param clz the converter will handle objects of this class (or sub-classes)
+ * @param appose_type the value for key "appose_type" in the returned Map
+ * @param converter accepts a map and a value, and serializes the value into the map somehow.
+ * @return a new converter
+ * @param object type handled by this converter
+ */
+ private static JsonGenerator.Converter convert(final Class clz, final String appose_type, final BiConsumer, T> converter) {
+ return new JsonGenerator.Converter() {
+
+ @Override
+ public boolean handles(final Class type) {
+ return clz.isAssignableFrom(type);
+ }
+
+ @SuppressWarnings("unchecked")
+ @Override
+ public Object convert(final Object value, final String key) {
+ final Map map = new LinkedHashMap<>();
+ map.put("appose_type", appose_type);
+ converter.accept(map, (T) value);
+ return map;
+ }
+ };
+ }
+
+ static final JsonGenerator GENERATOR = new JsonGenerator.Options() //
+ .addConverter(convert(SharedMemory.class, "shm", (map, shm) -> {
+ map.put("name", shm.name());
+ map.put("size", shm.size());
+ })).addConverter(convert(NDArray.class, "ndarray", (map, ndArray) -> {
+ map.put("dtype", ndArray.dType().label());
+ map.put("shape", ndArray.shape().toIntArray(C_ORDER));
+ map.put("shm", ndArray.shm());
+ })).build();
+
+
+ // == deserialization =====================================================
+
+ @SuppressWarnings("unchecked")
+ private static Map postProcess(Object parseResult) {
+ return processMap((Map) parseResult);
+ }
+
+ private static Map processMap(Map map) {
+ map.entrySet().forEach(entry -> entry.setValue(processValue(entry.getValue())));
+ return map;
+ }
+
+ @SuppressWarnings("unchecked")
+ private static Object processValue(Object value) {
+ if (value instanceof Map) {
+ final Map map = processMap((Map) value);
+ final Object v = map.get("appose_type");
+ if (v instanceof String) {
+ final String appose_type = (String) v;
+ switch (appose_type) {
+ case "shm":
+ final String name = (String) map.get("name");
+ final int size = (int) map.get("size");
+ return SharedMemory.attach(name, size);
+ case "ndarray":
+ final NDArray.DType dType = toDType((String) map.get("dtype"));
+ final NDArray.Shape shape = toShape((List) map.get("shape"));
+ final SharedMemory shm = (SharedMemory) map.get("shm");
+ return new NDArray(dType, shape, shm);
+ default:
+ System.err.println("unknown appose_type \"" + appose_type + "\"");
+ }
+ }
+ return map;
+ } else {
+ return value;
+ }
+ }
+
+ private static NDArray.DType toDType(final String dtype) {
+ return NDArray.DType.fromLabel(dtype);
+ }
+
+ private static NDArray.Shape toShape(final List shape) {
+ final int[] ints = new int[shape.size()];
+ Arrays.setAll(ints, shape::get);
+ return new NDArray.Shape(C_ORDER, ints);
+ }
}
diff --git a/src/main/java/org/apposed/appose/shm/CLibrary.java b/src/main/java/org/apposed/appose/shm/CLibrary.java
new file mode 100644
index 0000000..caca1e3
--- /dev/null
+++ b/src/main/java/org/apposed/appose/shm/CLibrary.java
@@ -0,0 +1,49 @@
+/*-
+ * #%L
+ * Appose: multi-language interprocess cooperation with shared memory.
+ * %%
+ * Copyright (C) 2023 - 2024 Appose developers.
+ * %%
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ * #L%
+ */
+package org.apposed.appose.shm;
+
+import com.sun.jna.Library;
+import com.sun.jna.Native;
+import com.sun.jna.Pointer;
+
+interface CLibrary extends Library {
+ CLibrary INSTANCE = Native.load("c", CLibrary.class);
+
+ int shm_open(String name, int oflag, int mode);
+ int ftruncate(int fd, int length);
+ Pointer mmap(Pointer addr, int length, int prot, int flags, int fd, int offset);
+ int munmap(Pointer addr, int length);
+ int close(int fd);
+ int shm_unlink(String name);
+
+ int SEEK_SET = 0;
+ int SEEK_CUR = 1;
+ int SEEK_END = 2;
+ long lseek(int fd, long offset, int whence);
+}
diff --git a/src/main/java/org/apposed/appose/shm/LibRt.java b/src/main/java/org/apposed/appose/shm/LibRt.java
new file mode 100644
index 0000000..28fd0f0
--- /dev/null
+++ b/src/main/java/org/apposed/appose/shm/LibRt.java
@@ -0,0 +1,49 @@
+/*-
+ * #%L
+ * Appose: multi-language interprocess cooperation with shared memory.
+ * %%
+ * Copyright (C) 2023 - 2024 Appose developers.
+ * %%
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ * #L%
+ */
+package org.apposed.appose.shm;
+
+import com.sun.jna.Library;
+import com.sun.jna.Native;
+import com.sun.jna.Pointer;
+
+interface LibRt extends Library {
+ LibRt INSTANCE = Native.load("rt", LibRt.class);
+
+ int shm_open(String name, int oflag, int mode);
+ int ftruncate(int fd, int length);
+ Pointer mmap(Pointer addr, int length, int prot, int flags, int fd, int offset);
+ int munmap(Pointer addr, int length);
+ int close(int fd);
+ int shm_unlink(String name);
+
+ int SEEK_SET = 0;
+ int SEEK_CUR = 1;
+ int SEEK_END = 2;
+ long lseek(int fd, long offset, int whence);
+}
diff --git a/src/main/java/org/apposed/appose/shm/MacosHelpers.java b/src/main/java/org/apposed/appose/shm/MacosHelpers.java
new file mode 100644
index 0000000..0fa281b
--- /dev/null
+++ b/src/main/java/org/apposed/appose/shm/MacosHelpers.java
@@ -0,0 +1,70 @@
+/*-
+ * #%L
+ * Appose: multi-language interprocess cooperation with shared memory.
+ * %%
+ * Copyright (C) 2023 - 2024 Appose developers.
+ * %%
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ * #L%
+ */
+
+package org.apposed.appose.shm;
+
+import com.sun.jna.Library;
+import com.sun.jna.Native;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.file.Files;
+import java.nio.file.StandardCopyOption;
+
+interface MacosHelpers extends Library {
+
+ String LIBRARY_NAME = "ShmCreate";
+
+ String LIBRARY_NAME_SUF = ".dylib";
+
+ // Load the native library
+ MacosHelpers INSTANCE = loadLibrary();
+
+ static MacosHelpers loadLibrary() {
+ try(
+ final InputStream in = MacosHelpers.class.getResourceAsStream(LIBRARY_NAME + LIBRARY_NAME_SUF);) {
+ final File tempFile = File.createTempFile(LIBRARY_NAME, LIBRARY_NAME_SUF);
+ tempFile.deleteOnExit();
+ Files.copy(in, tempFile.toPath(), StandardCopyOption.REPLACE_EXISTING);
+ return Native.load(tempFile.getAbsolutePath(), MacosHelpers.class);
+ }
+ catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ // Declare methods corresponding to the native functions
+ int create_shared_memory(String name, int size);
+
+ void unlink_shared_memory(String name);
+
+ long get_shared_memory_size(int fd);
+}
+
+
diff --git a/src/main/java/org/apposed/appose/shm/ShmBase.java b/src/main/java/org/apposed/appose/shm/ShmBase.java
new file mode 100644
index 0000000..83b6349
--- /dev/null
+++ b/src/main/java/org/apposed/appose/shm/ShmBase.java
@@ -0,0 +1,130 @@
+/*-
+ * #%L
+ * Appose: multi-language interprocess cooperation with shared memory.
+ * %%
+ * Copyright (C) 2023 - 2024 Appose developers.
+ * %%
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ * #L%
+ */
+
+package org.apposed.appose.shm;
+
+import com.sun.jna.Pointer;
+import org.apposed.appose.SharedMemory;
+
+/**
+ * Base class for platform-specific shared memory implementations.
+ *
+ * @author Carlos Garcia Lopez de Haro
+ * @author Tobias Pietzsch
+ * @author Curtis Rueden
+ */
+abstract class ShmBase implements SharedMemory {
+
+ /** Struct containing shm details, including name, size, pointer(s), and handle. */
+ protected final ShmInfo info;
+
+ /** Whether the memory block has been closed. */
+ private boolean closed;
+
+ /** Whether the memory block has been unlinked. */
+ private boolean unlinked;
+
+ protected ShmBase(final ShmInfo info) {
+ this.info = info;
+ }
+
+ protected abstract void doClose();
+ protected abstract void doUnlink();
+
+ @Override
+ public String name() {
+ return info.name;
+ }
+
+ @Override
+ public int size() {
+ return info.size;
+ }
+
+ @Override
+ public Pointer pointer() {
+ return info.pointer;
+ }
+
+ @Override
+ public void unlinkOnClose(boolean unlinkOnClose) {
+ info.unlinkOnClose = unlinkOnClose;
+ }
+
+ @Override
+ public synchronized void unlink() {
+ if (unlinked) throw new IllegalStateException("Shared memory '" + info.name + "' is already unlinked.");
+ doClose();
+ doUnlink();
+ unlinked = true;
+ }
+
+ @Override
+ public synchronized void close() {
+ if (closed) return;
+ doClose();
+ if (info.unlinkOnClose) doUnlink();
+ closed = true;
+ }
+
+ @Override
+ public String toString() {
+ StringBuilder sb = new StringBuilder();
+ sb.append(getClass().getSimpleName()).append("{");
+ sb.append("name='").append(name()).append("', size=").append(size());
+ if (info.pointer != null) sb.append(", pointer=").append(info.pointer);
+ if (info.writePointer != null) sb.append(", writePointer=").append(info.writePointer);
+ if (info.handle != null) sb.append("handle=").append(info.handle);
+ sb.append(", closed=").append(closed);
+ sb.append(", unlinked=").append(unlinked);
+ sb.append("}");
+ return sb.toString();
+ }
+
+ /** Struct containing details about this shared memory block. */
+ protected static class ShmInfo {
+
+ /** Unique name that identifies the shared memory segment. */
+ String name;
+
+ /** Size in bytes. */
+ int size;
+
+ /** Pointer referencing the shared memory. */
+ Pointer pointer;
+
+ Pointer writePointer;
+
+ /** File handle for the shared memory block's (pseudo-)file. */
+ HANDLE handle;
+
+ /** Whether to destroy the shared memory block when {@link #close()} is called. */
+ boolean unlinkOnClose;
+ }
+}
diff --git a/src/main/java/org/apposed/appose/shm/ShmLinux.java b/src/main/java/org/apposed/appose/shm/ShmLinux.java
new file mode 100644
index 0000000..85f021d
--- /dev/null
+++ b/src/main/java/org/apposed/appose/shm/ShmLinux.java
@@ -0,0 +1,255 @@
+/*-
+ * #%L
+ * Appose: multi-language interprocess cooperation with shared memory.
+ * %%
+ * Copyright (C) 2023 - 2024 Appose developers.
+ * %%
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ * #L%
+ */
+
+package org.apposed.appose.shm;
+
+import com.sun.jna.Native;
+import com.sun.jna.Pointer;
+import org.apposed.appose.SharedMemory;
+import org.apposed.appose.ShmFactory;
+
+import static org.apposed.appose.shm.ShmUtils.MAP_SHARED;
+import static org.apposed.appose.shm.ShmUtils.O_CREAT;
+import static org.apposed.appose.shm.ShmUtils.O_RDONLY;
+import static org.apposed.appose.shm.ShmUtils.O_RDWR;
+import static org.apposed.appose.shm.ShmUtils.PROT_READ;
+import static org.apposed.appose.shm.ShmUtils.PROT_WRITE;
+import static org.apposed.appose.shm.ShmUtils.SHM_NAME_PREFIX_POSIX;
+import static org.apposed.appose.shm.ShmUtils.SHM_SAFE_NAME_LENGTH;
+import static org.apposed.appose.shm.ShmUtils.withLeadingSlash;
+import static org.apposed.appose.shm.ShmUtils.withoutLeadingSlash;
+
+/**
+ * Linux-specific shared memory implementation.
+ *
+ * @author Carlos Garcia Lopez de Haro
+ * @author Tobias Pietzsch
+ * @author Curtis Rueden
+ */
+public class ShmLinux implements ShmFactory {
+
+ @Override
+ public SharedMemory create(final String name, final boolean create, final int size) {
+ if (ShmUtils.os != ShmUtils.OS.LINUX) return null; // wrong platform
+ return new SharedMemoryLinux(name, create, size);
+ }
+
+ private static class SharedMemoryLinux extends ShmBase {
+
+ // name without leading slash
+ private SharedMemoryLinux(final String name, final boolean create, final int size) {
+ super(prepareShm(name, create, size));
+ }
+
+ @Override
+ protected void doUnlink() {
+ LibRtOrC.shm_unlink(name());
+ }
+
+ @Override
+ protected void doClose() {
+ // Unmap the shared memory
+ if (pointer() != Pointer.NULL && LibRtOrC.munmap(pointer(), size()) == -1) {
+ throw new RuntimeException("munmap failed. Errno: " + Native.getLastError());
+ }
+
+ // Close the file descriptor
+ if (LibRtOrC.close(info.handle) == -1) {
+ throw new RuntimeException("close failed. Errno: " + Native.getLastError());
+ }
+ }
+
+ private static ShmInfo prepareShm(String name, boolean create, int size) {
+ String shm_name;
+ long prevSize;
+ if (name == null) {
+ do {
+ shm_name = ShmUtils.make_filename(SHM_SAFE_NAME_LENGTH, SHM_NAME_PREFIX_POSIX);
+ prevSize = getSHMSize(shm_name);
+ } while (prevSize >= 0);
+ } else {
+ shm_name = withLeadingSlash(name);
+ prevSize = getSHMSize(shm_name);
+ }
+ ShmUtils.checkSize(shm_name, prevSize, size);
+
+ final int shmFd = LibRtOrC.shm_open(shm_name, O_CREAT | O_RDWR, 0666);
+ if (shmFd < 0) {
+ throw new RuntimeException("shm_open failed, errno: " + Native.getLastError());
+ }
+ if (create) {
+ if (LibRtOrC.ftruncate(shmFd, (int) size) == -1) {
+ LibRtOrC.close(shmFd);
+ throw new RuntimeException("ftruncate failed, errno: " + Native.getLastError());
+ }
+ }
+ final int shm_size = (int) getSHMSize(shmFd);
+
+ Pointer pointer = LibRtOrC.mmap(Pointer.NULL, shm_size, PROT_READ | PROT_WRITE, MAP_SHARED, shmFd, 0);
+ if (pointer == Pointer.NULL) {
+ LibRtOrC.close(shmFd);
+ LibRtOrC.shm_unlink(shm_name);
+ throw new RuntimeException("mmap failed, errno: " + Native.getLastError());
+ }
+
+ ShmInfo info = new ShmInfo<>();
+ info.size = shm_size;
+ info.name = withoutLeadingSlash(shm_name);
+ info.pointer = pointer;
+ info.handle = shmFd;
+ info.unlinkOnClose = create;
+ return info;
+ }
+
+ /**
+ * Try to open {@code name} and get its size in bytes.
+ *
+ * @param name name with leading slash
+ * @return size in bytes, or -1 if the shared memory segment couuld not be opened
+ */
+ private static long getSHMSize(final String name) {
+ final int shmFd = LibRtOrC.shm_open(name, O_RDONLY, 0700);
+ if (shmFd < 0) {
+ return -1;
+ } else {
+ return getSHMSize(shmFd);
+ }
+ }
+
+ /**
+ * Method to find the size of an already created shared memory segment
+ *
+ * @param shmFd the shared memory segment identifier
+ * @return the size in bytes of the shared memory segment
+ */
+ private static long getSHMSize(final int shmFd) {
+ if (shmFd < 0) {
+ throw new RuntimeException("Invalid shmFd. It should be bigger than 0.");
+ }
+
+ final long size = LibRtOrC.lseek(shmFd, 0, LibRtOrC.SEEK_END);
+ if (size == -1) {
+ // TODO remove LibRtOrC.close(shmFd);
+ throw new RuntimeException("Failed to get shared memory segment size. Errno: " + Native.getLastError());
+ }
+ return size;
+ }
+
+ private static class LibRtOrC {
+
+ /**
+ * Depending on the computer, some might work with LibRT or LibC to create SHM segments.
+ * Thus if true use librt if false, use libc instance
+ */
+ private static boolean useLibRT = true;
+
+ static final int SEEK_SET = 0;
+ static final int SEEK_CUR = 1;
+ static final int SEEK_END = 2;
+
+ static int shm_open(String name, int oflag, int mode) {
+ if (useLibRT) {
+ try {
+ return LibRt.INSTANCE.shm_open(name, oflag, mode);
+ } catch (Exception ex) {
+ useLibRT = false;
+ }
+ }
+ return CLibrary.INSTANCE.shm_open(name, oflag, mode);
+ }
+
+ static long lseek(int fd, long offset, int whence) {
+ if (useLibRT) {
+ try {
+ return LibRt.INSTANCE.lseek(fd, offset, whence);
+ } catch (Exception ex) {
+ useLibRT = false;
+ }
+ }
+ return CLibrary.INSTANCE.lseek(fd, offset, whence);
+ }
+
+ static int ftruncate(int fd, int length) {
+ if (useLibRT) {
+ try {
+ return LibRt.INSTANCE.ftruncate(fd, length);
+ } catch (Exception ex) {
+ useLibRT = false;
+ }
+ }
+ return CLibrary.INSTANCE.ftruncate(fd, length);
+ }
+
+
+ static Pointer mmap(Pointer addr, int length, int prot, int flags, int fd, int offset) {
+ if (useLibRT) {
+ try {
+ return LibRt.INSTANCE.mmap(addr, length, prot, flags, fd, offset);
+ } catch (Exception ex) {
+ useLibRT = false;
+ }
+ }
+ return CLibrary.INSTANCE.mmap(addr, length, prot, flags, fd, offset);
+ }
+
+ static int munmap(Pointer addr, int length) {
+ if (useLibRT) {
+ try {
+ return LibRt.INSTANCE.munmap(addr, length);
+ } catch (Exception ex) {
+ useLibRT = false;
+ }
+ }
+ return CLibrary.INSTANCE.munmap(addr, length);
+ }
+
+ static int close(int fd) {
+ if (useLibRT) {
+ try {
+ return LibRt.INSTANCE.close(fd);
+ } catch (Exception ex) {
+ useLibRT = false;
+ }
+ }
+ return CLibrary.INSTANCE.close(fd);
+ }
+
+ static int shm_unlink(String name) {
+ if (useLibRT) {
+ try {
+ return LibRt.INSTANCE.shm_unlink(name);
+ } catch (Exception ex) {
+ useLibRT = false;
+ }
+ }
+ return CLibrary.INSTANCE.shm_unlink(name);
+ }
+ }
+ }
+}
diff --git a/src/main/java/org/apposed/appose/shm/ShmMacOS.java b/src/main/java/org/apposed/appose/shm/ShmMacOS.java
new file mode 100644
index 0000000..bb4d405
--- /dev/null
+++ b/src/main/java/org/apposed/appose/shm/ShmMacOS.java
@@ -0,0 +1,155 @@
+/*-
+ * #%L
+ * Appose: multi-language interprocess cooperation with shared memory.
+ * %%
+ * Copyright (C) 2023 - 2024 Appose developers.
+ * %%
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ * #L%
+ */
+
+package org.apposed.appose.shm;
+
+import com.sun.jna.Native;
+import com.sun.jna.Pointer;
+import org.apposed.appose.SharedMemory;
+import org.apposed.appose.ShmFactory;
+
+import static org.apposed.appose.shm.ShmUtils.MAP_SHARED;
+import static org.apposed.appose.shm.ShmUtils.O_RDONLY;
+import static org.apposed.appose.shm.ShmUtils.PROT_READ;
+import static org.apposed.appose.shm.ShmUtils.PROT_WRITE;
+import static org.apposed.appose.shm.ShmUtils.SHM_NAME_PREFIX_POSIX;
+import static org.apposed.appose.shm.ShmUtils.SHM_SAFE_NAME_LENGTH;
+import static org.apposed.appose.shm.ShmUtils.withLeadingSlash;
+import static org.apposed.appose.shm.ShmUtils.withoutLeadingSlash;
+
+/**
+ * MacOS-specific shared memory implementation.
+ *
+ * @author Carlos Garcia Lopez de Haro
+ * @author Tobias Pietzsch
+ * @author Curtis Rueden
+ */
+public class ShmMacOS implements ShmFactory {
+
+ @Override
+ public SharedMemory create(final String name, final boolean create, final int size) {
+ if (ShmUtils.os != ShmUtils.OS.OSX) return null; // wrong platform
+ return new SharedMemoryMacOS(name, create, size);
+ }
+
+ private static class SharedMemoryMacOS extends ShmBase {
+ private SharedMemoryMacOS(final String name, final boolean create, final int size) {
+ super(prepareShm(name, create, size));
+ }
+
+ @Override
+ protected void doUnlink() {
+ CLibrary.INSTANCE.shm_unlink(name());
+ }
+
+ @Override
+ protected void doClose() {
+ // Unmap the shared memory
+ if (pointer() != Pointer.NULL && CLibrary.INSTANCE.munmap(pointer(), size()) == -1) {
+ throw new RuntimeException("munmap failed. Errno: " + Native.getLastError());
+ }
+
+ // Close the file descriptor
+ if (CLibrary.INSTANCE.close(info.handle) == -1) {
+ throw new RuntimeException("close failed. Errno: " + Native.getLastError());
+ }
+ }
+
+ private static ShmInfo prepareShm(String name, boolean create, int size) {
+ String shm_name;
+ long prevSize;
+ if (name == null) {
+ do {
+ shm_name = ShmUtils.make_filename(SHM_SAFE_NAME_LENGTH, SHM_NAME_PREFIX_POSIX);
+ prevSize = getSHMSize(shm_name);
+ } while (prevSize >= 0);
+ } else {
+ shm_name = withLeadingSlash(name);
+ prevSize = getSHMSize(shm_name);
+ }
+ ShmUtils.checkSize(shm_name, prevSize, size);
+
+ // shmFd = INSTANCE.shm_open(this.memoryName, O_RDWR, 0666);
+ final int shmFd = MacosHelpers.INSTANCE.create_shared_memory(shm_name, size);
+ if (shmFd < 0) {
+ throw new RuntimeException("shm_open failed, errno: " + Native.getLastError());
+ }
+ final int shm_size = (int) getSHMSize(shmFd);
+
+ Pointer pointer = CLibrary.INSTANCE.mmap(Pointer.NULL, shm_size, PROT_READ | PROT_WRITE, MAP_SHARED, shmFd, 0);
+ if (pointer == Pointer.NULL) {
+ CLibrary.INSTANCE.close(shmFd);
+ CLibrary.INSTANCE.shm_unlink(shm_name);
+ throw new RuntimeException("mmap failed, errno: " + Native.getLastError());
+ }
+
+ ShmInfo info = new ShmInfo<>();
+ info.size = shm_size;
+ info.name = withoutLeadingSlash(shm_name);
+ info.pointer = pointer;
+ info.handle = shmFd;
+ info.unlinkOnClose = create;
+ return info;
+ }
+
+ /**
+ * Try to open {@code name} and get its size in bytes.
+ *
+ * @param name name with leading slash
+ * @return size in bytes, or -1 if the shared memory segment couuld not be opened
+ */
+ private static long getSHMSize(final String name) {
+ final int shmFd = CLibrary.INSTANCE.shm_open(name, O_RDONLY, 0700);
+ if (shmFd < 0) {
+ return -1;
+ } else {
+ return getSHMSize(shmFd);
+ }
+ }
+
+ /**
+ * Method to find the size of an already created shared memory segment
+ *
+ * @param shmFd the shared memory segment identifier
+ * @return the size in bytes of the shared memory segment
+ */
+ private static long getSHMSize(final int shmFd) {
+ if (shmFd < 0) {
+ throw new RuntimeException("Invalid shmFd. It should be bigger than 0.");
+ }
+
+ final long size = MacosHelpers.INSTANCE.get_shared_memory_size(shmFd);
+ if (size == -1) {
+ // TODO remove macosInstance.unlink_shared_memory(null);;
+ throw new RuntimeException("Failed to get shared memory segment size. Errno: " + Native.getLastError());
+ }
+ return size;
+ }
+ }
+}
diff --git a/src/main/java/org/apposed/appose/shm/ShmUtils.java b/src/main/java/org/apposed/appose/shm/ShmUtils.java
new file mode 100644
index 0000000..afd6bbf
--- /dev/null
+++ b/src/main/java/org/apposed/appose/shm/ShmUtils.java
@@ -0,0 +1,161 @@
+/*-
+ * #%L
+ * Appose: multi-language interprocess cooperation with shared memory.
+ * %%
+ * Copyright (C) 2023 - 2024 Appose developers.
+ * %%
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ * #L%
+ */
+package org.apposed.appose.shm;
+
+import java.util.Random;
+
+import static org.apposed.appose.shm.ShmUtils.OS.LINUX;
+import static org.apposed.appose.shm.ShmUtils.OS.OSX;
+import static org.apposed.appose.shm.ShmUtils.OS.WINDOWS;
+
+/**
+ * Utilities used in all platform-specific {@code SharedMemory} implementations.
+ */
+class ShmUtils {
+
+ /**
+ * Constant to specify that the shared memory segment that is going to be
+ * open is only for reading
+ */
+ static int O_RDONLY = 0;
+
+ /**
+ * Constant to specify that the shared memory segment that is going to be
+ * open is for reading and/or writing
+ */
+ static int O_RDWR = 2;
+
+ /**
+ * Constant to specify that the shared memory segment that is going to be
+ * open will be created if it does not exist
+ */
+ static int O_CREAT = 64;
+
+ /**
+ * Constant to specify that the shared memory regions mapped can be read but
+ * not written
+ */
+ static int PROT_READ = 0x1;
+
+ /**
+ * Constant to specify that the shared memory regions mapped can be written
+ */
+ static int PROT_WRITE = 0x2;
+
+ /**
+ * Constant to specify that the shared memory regions mapped can be shared
+ * with other processes
+ */
+ static int MAP_SHARED = 0x01;
+
+ /**
+ * The detected OS.
+ */
+ public static final OS os = detect_os();
+
+ enum OS {WINDOWS, OSX, LINUX}
+
+ private static OS detect_os() {
+ final String os_name = System.getProperty("os.name").toLowerCase();
+ if (os_name.startsWith("windows")) {
+ return WINDOWS;
+ } else if (os_name.startsWith("mac")) {
+ return OSX;
+ } else if (os_name.contains("linux") || os_name.endsWith("ix")) {
+ return LINUX;
+ }
+ throw new RuntimeException("OS detection failed. System.getProperty(\"os.name\") = " + System.getProperty("os.name"));
+ }
+
+ /**
+ * Add leading slash if {@code name} doesn't have one.
+ */
+ static String withLeadingSlash(String name) {
+ return name.startsWith("/") ? name : ("/" + name);
+ }
+
+ /**
+ * Remove leading slash if {@code name} has one.
+ */
+ static String withoutLeadingSlash(String name) {
+ return name.startsWith("/") ? name.substring(1) : name;
+ }
+
+ /**
+ * FreeBSD (and perhaps other BSDs) limit names to 14 characters.
+ */
+ static final int SHM_SAFE_NAME_LENGTH = 14;
+
+ /**
+ * Shared memory block name prefix for Mac and Linux
+ */
+ static final String SHM_NAME_PREFIX_POSIX = "/psm_";
+
+ /**
+ * Shared memory block name prefix for Windows
+ */
+ static final String SHM_NAME_PREFIX_WIN = "wnsm_";
+
+ /**
+ * Creates a random filename for the shared memory object.
+ *
+ * @param maxLength maximum length of the generated name
+ * @param prefix prefix of the generated filename
+ * @return a random filename with the given {@code prefix}.
+ */
+ static String make_filename(int maxLength, String prefix) {
+ // number of random bytes to use for name
+ final int nbytes = (maxLength - prefix.length()) / 2;
+ if (nbytes < 2) {
+ throw new IllegalArgumentException("prefix too long");
+ }
+ final String name = prefix + token_hex(nbytes);
+ assert name.length() <= maxLength;
+ return name;
+ }
+
+ static void checkSize(String shmName, long prevSize, int size) {
+ final boolean alreadyExists = prevSize >= 0;
+ if (alreadyExists && prevSize < size) {
+ throw new RuntimeException("Shared memory segment '" + shmName + "' already exists with smaller size. "
+ + "Size of the existing shared memory segment cannot be smaller than the size of the proposed object. "
+ + "Size of existing shared memory segment: " + prevSize + ", size of proposed object: " + size);
+ }
+ }
+
+ private static String token_hex(int nbytes) {
+ final byte[] bytes = new byte[nbytes];
+ new Random().nextBytes(bytes);
+ StringBuilder sb = new StringBuilder(nbytes * 2);
+ for (byte b : bytes) {
+ sb.append(String.format("%02x", b & 0xff));
+ }
+ return sb.toString();
+ }
+}
diff --git a/src/main/java/org/apposed/appose/shm/ShmWindows.java b/src/main/java/org/apposed/appose/shm/ShmWindows.java
new file mode 100644
index 0000000..b52c91e
--- /dev/null
+++ b/src/main/java/org/apposed/appose/shm/ShmWindows.java
@@ -0,0 +1,221 @@
+/*-
+ * #%L
+ * Appose: multi-language interprocess cooperation with shared memory.
+ * %%
+ * Copyright (C) 2023 - 2024 Appose developers.
+ * %%
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ * #L%
+ */
+
+package org.apposed.appose.shm;
+
+import com.sun.jna.Pointer;
+import com.sun.jna.platform.win32.BaseTSD;
+import com.sun.jna.platform.win32.Kernel32;
+import com.sun.jna.platform.win32.WinBase;
+import com.sun.jna.platform.win32.WinNT;
+import org.apposed.appose.SharedMemory;
+import org.apposed.appose.ShmFactory;
+
+import static org.apposed.appose.shm.ShmUtils.SHM_NAME_PREFIX_WIN;
+import static org.apposed.appose.shm.ShmUtils.SHM_SAFE_NAME_LENGTH;
+
+/**
+ * Windows-specific shared memory implementation.
+ *
+ * TODO separate unlink and close
+ *
+ *
+ * @author Carlos Garcia Lopez de Haro
+ * @author Tobias Pietzsch
+ */
+public class ShmWindows implements ShmFactory {
+
+ // name is WITHOUT prefix etc
+ @Override
+ public SharedMemory create(final String name, final boolean create, final int size) {
+ if (ShmUtils.os != ShmUtils.OS.WINDOWS) return null; // wrong platform
+ return new SharedMemoryWindows(name, create, size);
+ }
+
+ private static class SharedMemoryWindows extends ShmBase {
+
+ private SharedMemoryWindows(final String name, final boolean create, final int size) {
+ super(prepareShm(name, create, size));
+ }
+
+ @Override
+ protected void doClose() {
+ cleanup(info.pointer, info.writePointer, info.handle);
+ }
+
+ @Override
+ protected void doUnlink() {
+ // Note: The shared memory object will be deleted when all processes
+ // have closed their handles to it. There's no direct "unlink"
+ // equivalent in Windows like there is in POSIX systems.
+ }
+
+ private static ShmInfo prepareShm(String name, boolean create, int size) {
+ String shm_name;
+ long prevSize;
+ if (name == null) {
+ do {
+ shm_name = ShmUtils.make_filename(SHM_SAFE_NAME_LENGTH, SHM_NAME_PREFIX_WIN);
+ prevSize = getSHMSize(shm_name);
+ } while (prevSize >= 0);
+ } else {
+ shm_name = nameMangle_TODO(name);
+ prevSize = getSHMSize(shm_name);
+ }
+ ShmUtils.checkSize(shm_name, prevSize, size);
+
+ final WinNT.HANDLE hMapFile = Kernel32.INSTANCE.CreateFileMapping(
+ WinBase.INVALID_HANDLE_VALUE,
+ null,
+ WinNT.PAGE_READWRITE,
+ 0,
+ size,
+ shm_name
+ );
+ if (hMapFile == null) {
+ throw new RuntimeException("Error creating shared memory array. CreateFileMapping failed: " + Kernel32.INSTANCE.GetLastError());
+ }
+
+ final int shm_size = (int) getSHMSize(hMapFile);
+
+ // Map the shared memory
+ Pointer pointer = Kernel32.INSTANCE.MapViewOfFile(
+ hMapFile,
+ WinNT.FILE_MAP_WRITE,
+ 0,
+ 0,
+ size
+ );
+ if (isNull(pointer)) {
+ Kernel32.INSTANCE.CloseHandle(hMapFile);
+ throw new RuntimeException("Error creating shared memory array. " + Kernel32.INSTANCE.GetLastError());
+ }
+
+ Pointer writePointer = Kernel32.INSTANCE.VirtualAllocEx(Kernel32.INSTANCE.GetCurrentProcess(),
+ pointer, new BaseTSD.SIZE_T(size), WinNT.MEM_COMMIT, WinNT.PAGE_READWRITE);
+ if (isNull(writePointer)) {
+ cleanup(pointer, writePointer, hMapFile);
+ throw new RuntimeException("Error committing to the shared memory pages. Errno: " + Kernel32.INSTANCE.GetLastError());
+ }
+
+ ShmInfo info = new ShmInfo<>();
+ info.size = shm_size;
+ info.name = nameUnmangle_TODO(shm_name);
+ info.pointer = pointer;
+ info.writePointer = writePointer;
+ info.handle = hMapFile;
+ info.unlinkOnClose = create;
+ return info;
+ }
+
+ // TODO equivalent of removing slash
+ private static String nameUnmangle_TODO (String memoryName){
+ return memoryName;
+ }
+
+ // TODO equivalent of adding slash
+ // Do we need the "Local\" prefix?
+ private static String nameMangle_TODO (String memoryName){
+ // if (!memoryName.startsWith("Local" + File.separator) && !memoryName.startsWith("Global" + File.separator))
+ // memoryName = "Local" + File.separator + memoryName;
+ return memoryName;
+ }
+
+ // name is WITH prefix etc
+ private static boolean checkSHMExists ( final String name){
+ final WinNT.HANDLE hMapFile = Kernel32.INSTANCE.OpenFileMapping(WinNT.FILE_MAP_READ, false, name);
+ if (hMapFile == null) {
+ return false;
+ } else {
+ Kernel32.INSTANCE.CloseHandle(hMapFile);
+ return true;
+ }
+ }
+
+ /**
+ * Try to open {@code name} and get its size in bytes.
+ *
+ * @param name name with leading slash
+ * @return size in bytes, or -1 if the shared memory segment couuld not be opened
+ */
+ // name is WITH prefix etc
+ private static long getSHMSize(final String name) {
+ WinNT.HANDLE hMapFile = Kernel32.INSTANCE.OpenFileMapping(WinNT.FILE_MAP_READ, false, name);
+ if (hMapFile == null) {
+ return -1;
+ } else {
+ return getSHMSize(hMapFile);
+ }
+ }
+
+ /**
+ * Method to find the size of an already created shared memory segment
+ *
+ * @param hMapFile
+ * the shared memory segment handle
+ *
+ * @return the size in bytes of the shared memory segment
+ */
+ private static long getSHMSize(final WinNT.HANDLE hMapFile) {
+ if (hMapFile == null) {
+ throw new NullPointerException("hMapFile is null.");
+ }
+
+ // Map the shared memory object into the current process's address space
+ final Pointer pSharedMemory = Kernel32.INSTANCE.MapViewOfFile(hMapFile, WinNT.FILE_MAP_READ, 0, 0, 0);
+ if (pSharedMemory == null) {
+ Kernel32.INSTANCE.CloseHandle(hMapFile);
+ throw new RuntimeException("MapViewOfFile failed with error: " + Kernel32.INSTANCE.GetLastError());
+ }
+ final Kernel32.MEMORY_BASIC_INFORMATION mbi = new Kernel32.MEMORY_BASIC_INFORMATION();
+
+ if (
+ Kernel32.INSTANCE.VirtualQueryEx(
+ Kernel32.INSTANCE.GetCurrentProcess(), pSharedMemory,
+ mbi, new BaseTSD.SIZE_T((long) mbi.size())
+ ).intValue() == 0) {
+ throw new RuntimeException("Failed to get shared memory segment size. Errno: " + Kernel32.INSTANCE.GetLastError());
+ }
+ final int size = mbi.regionSize.intValue();
+
+ Kernel32.INSTANCE.UnmapViewOfFile(pSharedMemory);
+ Kernel32.INSTANCE.CloseHandle(hMapFile);
+
+ return size;
+ }
+ }
+
+ private static void cleanup(Pointer pointer, Pointer writePointer, WinNT.HANDLE handle) {
+ if (!isNull(writePointer)) Kernel32.INSTANCE.UnmapViewOfFile(writePointer);
+ if (!isNull(pointer)) Kernel32.INSTANCE.UnmapViewOfFile(pointer);
+ if (handle != null) Kernel32.INSTANCE.CloseHandle(handle);
+ }
+
+ private static boolean isNull(Pointer p) { return p == null || p == Pointer.NULL; }
+}
diff --git a/src/main/resources/META-INF/services/org.apposed.appose.ShmFactory b/src/main/resources/META-INF/services/org.apposed.appose.ShmFactory
new file mode 100644
index 0000000..ea5d690
--- /dev/null
+++ b/src/main/resources/META-INF/services/org.apposed.appose.ShmFactory
@@ -0,0 +1,3 @@
+org.apposed.appose.shm.ShmLinux
+org.apposed.appose.shm.ShmMacOS
+org.apposed.appose.shm.ShmWindows
diff --git a/src/main/resources/org/apposed/appose/shm/ShmCreate.dylib b/src/main/resources/org/apposed/appose/shm/ShmCreate.dylib
new file mode 100755
index 0000000..191fa08
Binary files /dev/null and b/src/main/resources/org/apposed/appose/shm/ShmCreate.dylib differ
diff --git a/src/test/java/org/apposed/appose/ApposeTest.java b/src/test/java/org/apposed/appose/ApposeTest.java
index 0804b42..3b82c55 100644
--- a/src/test/java/org/apposed/appose/ApposeTest.java
+++ b/src/test/java/org/apposed/appose/ApposeTest.java
@@ -2,7 +2,7 @@
* #%L
* Appose: multi-language interprocess cooperation with shared memory.
* %%
- * Copyright (C) 2023 Appose developers.
+ * Copyright (C) 2023 - 2024 Appose developers.
* %%
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
@@ -45,27 +45,27 @@
public class ApposeTest {
- private static final String COLLATZ_GROOVY = "" + //
- "// Computes the stopping time of a given value\n" + //
- "// according to the Collatz conjecture sequence.\n" + //
- "time = 0\n" + //
+ private static final String COLLATZ_GROOVY =
+ "// Computes the stopping time of a given value\n" +
+ "// according to the Collatz conjecture sequence.\n" +
+ "time = 0\n" +
"BigInteger v = 9999\n" +
- "while (v != 1) {\n" + //
- " v = v%2==0 ? v/2 : 3*v+1\n" + //
- " task.update(\"[${time}] -> ${v}\", time, null)\n" + //
- " time++\n" + //
- "}\n" + //
+ "while (v != 1) {\n" +
+ " v = v%2==0 ? v/2 : 3*v+1\n" +
+ " task.update(\"[${time}] -> ${v}\", time, null)\n" +
+ " time++\n" +
+ "}\n" +
"return time\n";
- private static final String COLLATZ_PYTHON = "" + //
- "# Computes the stopping time of a given value\n" + //
- "# according to the Collatz conjecture sequence.\n" + //
- "time = 0\n" + //
+ private static final String COLLATZ_PYTHON =
+ "# Computes the stopping time of a given value\n" +
+ "# according to the Collatz conjecture sequence.\n" +
+ "time = 0\n" +
"v = 9999\n" +
- "while v != 1:\n" + //
- " v = v//2 if v%2==0 else 3*v+1\n" + //
- " task.update(f\"[{time}] -> {v}\", current=time)\n" + //
- " time += 1\n" + //
+ "while v != 1:\n" +
+ " v = v//2 if v%2==0 else 3*v+1\n" +
+ " task.update(f\"[{time}] -> {v}\", current=time)\n" +
+ " time += 1\n" +
"task.outputs[\"result\"] = time\n";
@Test
@@ -108,12 +108,12 @@ public void executeAndAssert(Service service, String script)
// Record the state of the task for each event that occurs.
class TaskState {
- ResponseType responseType;
- TaskStatus status;
- String message;
- Long current;
- Long maximum;
- String error;
+ final ResponseType responseType;
+ final TaskStatus status;
+ final String message;
+ final Long current;
+ final Long maximum;
+ final String error;
TaskState(TaskEvent event) {
responseType = event.responseType;
status = event.task.status;
diff --git a/src/test/java/org/apposed/appose/NDArrayExampleGroovy.java b/src/test/java/org/apposed/appose/NDArrayExampleGroovy.java
new file mode 100644
index 0000000..b3bc045
--- /dev/null
+++ b/src/test/java/org/apposed/appose/NDArrayExampleGroovy.java
@@ -0,0 +1,74 @@
+/*-
+ * #%L
+ * Appose: multi-language interprocess cooperation with shared memory.
+ * %%
+ * Copyright (C) 2023 - 2024 Appose developers.
+ * %%
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ * #L%
+ */
+package org.apposed.appose;
+
+import java.nio.FloatBuffer;
+import java.util.HashMap;
+import java.util.Map;
+
+import static org.apposed.appose.NDArray.Shape.Order.F_ORDER;
+
+public class NDArrayExampleGroovy {
+
+ public static void main(String[] args) throws Exception {
+
+ // create a FLOAT32 NDArray with shape (4,3,2) in F_ORDER
+ // respectively (2,3,4) in C_ORDER
+ final NDArray.DType dType = NDArray.DType.FLOAT32;
+ final NDArray.Shape shape = new NDArray.Shape(F_ORDER, 4, 3, 2);
+ final NDArray ndArray = new NDArray(dType, shape);
+
+ // fill with values 0..23 in flat iteration order
+ final FloatBuffer buf = ndArray.buffer().asFloatBuffer();
+ final long len = ndArray.shape().numElements();
+ for ( int i = 0; i < len; ++i ) {
+ buf.put(i, i);
+ }
+
+ System.out.println("ndArray.shm().size() = " + ndArray.shm().size());
+ System.out.println("ndArray.shm().name() = " + ndArray.shm().name());
+ float v = ndArray.buffer().asFloatBuffer().get(5);
+ System.out.println("v = " + v);
+
+ // pass to groovy
+ Environment env = Appose.system();
+ try (Service service = env.groovy()) {
+ final Map< String, Object > inputs = new HashMap<>();
+ inputs.put( "img", ndArray);
+ Service.Task task = service.task(PRINT_INPUT, inputs );
+ task.waitFor();
+ System.out.println( "result = " + task.outputs.get("result") );
+ }
+ ndArray.close();
+ }
+
+ private static final String PRINT_INPUT = "" + //
+ "return \"[\" + img.buffer().asFloatBuffer().get(5) + \"]\";\n";
+
+}
diff --git a/src/test/java/org/apposed/appose/NDArrayExamplePython.java b/src/test/java/org/apposed/appose/NDArrayExamplePython.java
new file mode 100644
index 0000000..e37582c
--- /dev/null
+++ b/src/test/java/org/apposed/appose/NDArrayExamplePython.java
@@ -0,0 +1,72 @@
+/*-
+ * #%L
+ * Appose: multi-language interprocess cooperation with shared memory.
+ * %%
+ * Copyright (C) 2023 - 2024 Appose developers.
+ * %%
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ * #L%
+ */
+package org.apposed.appose;
+
+import java.nio.FloatBuffer;
+import java.util.HashMap;
+import java.util.Map;
+
+import static org.apposed.appose.NDArray.Shape.Order.F_ORDER;
+
+public class NDArrayExamplePython {
+
+ public static void main(String[] args) throws Exception {
+
+ // create a FLOAT32 NDArray with shape (4,3,2) in F_ORDER
+ // respectively (2,3,4) in C_ORDER
+ final NDArray.DType dType = NDArray.DType.FLOAT32;
+ final NDArray.Shape shape = new NDArray.Shape(F_ORDER, 4, 3, 2);
+ final NDArray ndArray = new NDArray(dType, shape);
+
+ // fill with values 0..23 in flat iteration order
+ final FloatBuffer buf = ndArray.buffer().asFloatBuffer();
+ final long len = ndArray.shape().numElements();
+ for ( int i = 0; i < len; ++i ) {
+ buf.put(i, i);
+ }
+
+ // pass to python (will be wrapped as numpy ndarray
+ final Environment env = Appose.base( "/opt/homebrew/Caskroom/miniforge/base/envs/appose/" ).build();
+ try ( Service service = env.python() ) {
+ final Map< String, Object > inputs = new HashMap<>();
+ inputs.put( "img", ndArray);
+ Service.Task task = service.task(PRINT_INPUT, inputs );
+ task.waitFor();
+ final String result = ( String ) task.outputs.get( "result" );
+ System.out.println( "result = \n" + result );
+ }
+ ndArray.close();
+ }
+
+
+ private static final String PRINT_INPUT = "" + //
+ "import numpy as np\n" + //
+ "task.outputs['result'] = str(img.ndarray())";
+
+}
diff --git a/src/test/java/org/apposed/appose/SharedMemoryTest.java b/src/test/java/org/apposed/appose/SharedMemoryTest.java
new file mode 100644
index 0000000..59b4e6a
--- /dev/null
+++ b/src/test/java/org/apposed/appose/SharedMemoryTest.java
@@ -0,0 +1,147 @@
+/*-
+ * #%L
+ * Appose: multi-language interprocess cooperation with shared memory.
+ * %%
+ * Copyright (C) 2023 - 2024 Appose developers.
+ * %%
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ * #L%
+ */
+
+package org.apposed.appose;
+
+import org.junit.jupiter.api.Test;
+
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.nio.ByteBuffer;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
+/**
+ * Tests {@link SharedMemory}.
+ *
+ * @author Curtis Rueden
+ */
+public class SharedMemoryTest {
+
+ @Test
+ public void testShmCreate() throws IOException {
+ int size = 456;
+ try (SharedMemory shm = SharedMemory.create(null, size)) {
+ assertNotNull(shm.name());
+ assertEquals(size, shm.size());
+ assertNotNull(shm.pointer());
+
+ // Modify the memory contents.
+ ByteBuffer buffer = shm.pointer().getByteBuffer(0, size);
+ for (int i = 0; i < size; i++) {
+ buffer.put(i, (byte) (size - i));
+ }
+
+ // Assert that values have been modified as expected.
+ byte[] b = new byte[size];
+ buffer.get(b);
+ for (int i = 0; i < size; i++) {
+ assertEquals((byte) (size - i), b[i]);
+ }
+
+ // Assert that another process is able to read the values.
+ String output = runPython(
+ "from multiprocessing.shared_memory import SharedMemory\n" +
+ "from sys import stdout\n" +
+ "shm = SharedMemory(name='" + shm.name() + "', size=" + shm.size() + ")\n" +
+ "matches = sum(1 for i in range(shm.size) if shm.buf[i] == (shm.size - i) % 256)\n" +
+ "stdout.write(f'{matches}\\n')\n" +
+ "stdout.flush()\n" +
+ "shm.unlink()\n" // HACK: to satisfy Python's overly aggressive resource tracker
+ );
+ assertEquals("" + size, output);
+ }
+ }
+
+ @Test
+ public void testShmAttach() throws IOException {
+ // Create a named shared memory block in a separate process.
+ // NB: I originally tried passing the Python script as an argument to `-c`,
+ // but it gets truncated (don't know why) and the program fails to execute.
+ // So instead, the program is passed in via stdin. But that means the
+ // program itself cannot read from stdin as a means of waiting for Java to
+ // signal its completion of the test asserts; we use a hacky sleep instead.
+ String output = runPython(
+ "from multiprocessing.shared_memory import SharedMemory\n" +
+ "from sys import stdout\n" +
+ "shm = SharedMemory(create=True, size=345)\n" +
+ "shm.buf[0] = 12\n" +
+ "shm.buf[100] = 234\n" +
+ "shm.buf[344] = 7\n" +
+ "stdout.write(f'{shm.name}|{shm.size}\\n')\n" +
+ "stdout.flush()\n" +
+ "import time; time.sleep(0.2)\n" + // HACK: horrible, but keeps things simple
+ "shm.unlink()\n"
+ );
+
+ // Parse the output into the name and size of the shared memory block.
+ String[] shmInfo = output.split("\\|");
+ assertEquals(2, shmInfo.length);
+ String shmName = shmInfo[0];
+ assertNotNull(shmName);
+ assertFalse(shmName.isEmpty());
+ int shmSize = Integer.parseInt(shmInfo[1]);
+ assertEquals(345, shmSize);
+
+ // Attach to the shared memory and verify it matches expectations.
+ try (SharedMemory shm = SharedMemory.attach(shmName, shmSize)) {
+ assertNotNull(shm);
+ assertEquals(shmName, shm.name());
+ assertEquals(shmSize, shm.size());
+ ByteBuffer buf = shm.pointer().getByteBuffer(0, shmSize);
+ assertEquals(12, buf.get(0));
+ assertEquals((byte) 234, buf.get(100));
+ assertEquals(7, buf.get(344));
+ }
+
+ // NB: No need to clean up the shared memory explicitly,
+ // since the Python program will unlink it and terminate
+ // upon completion of the sleep instruction.
+ }
+
+ private static String runPython(String script) throws IOException {
+ boolean isWindows = System.getProperty("os.name").startsWith("Win");
+ String pythonCommand = isWindows ? "python.exe" : "python";
+ ProcessBuilder pb = new ProcessBuilder().command(pythonCommand);
+ Process p = pb.start();
+ try (BufferedWriter os = new BufferedWriter(new OutputStreamWriter(p.getOutputStream()))) {
+ os.write(script);
+ os.flush();
+ }
+ BufferedReader is = new BufferedReader(new InputStreamReader(p.getInputStream()));
+ String line = is.readLine();
+ assertNotNull(line, "Python program returned no output");
+ return line;
+ }
+}
diff --git a/src/test/java/org/apposed/appose/TypesTest.java b/src/test/java/org/apposed/appose/TypesTest.java
new file mode 100644
index 0000000..06e7e39
--- /dev/null
+++ b/src/test/java/org/apposed/appose/TypesTest.java
@@ -0,0 +1,169 @@
+/*-
+ * #%L
+ * Appose: multi-language interprocess cooperation with shared memory.
+ * %%
+ * Copyright (C) 2023 - 2024 Appose developers.
+ * %%
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ * #L%
+ */
+
+package org.apposed.appose;
+
+import org.junit.jupiter.api.Test;
+
+import java.math.BigDecimal;
+import java.util.Arrays;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertSame;
+
+/**
+ * Tests {@link Types}.
+ *
+ * @author Curtis Rueden
+ */
+public class TypesTest {
+
+ private static final String JSON = "{" +
+ "\"posByte\":123,\"negByte\":-98," +
+ "\"posDouble\":9.876543210123456,\"negDouble\":-1.234567890987654E302," +
+ "\"posFloat\":9.876543,\"negFloat\":-1.2345678," +
+ "\"posInt\":1234567890,\"negInt\":-987654321," +
+ "\"posLong\":12345678987654321,\"negLong\":-98765432123456789," +
+ "\"posShort\":32109,\"negShort\":-23456," +
+ "\"trueBoolean\":true,\"falseBoolean\":false," +
+ "\"aChar\":\"\\u0000\"," +
+ "\"aString\":\"-=[]\\\\;',./_+{}|:\\\"<>?" +
+ "AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz" +
+ "~!@#$%^&*()\"," +
+ "\"numbers\":[1,1,2,3,5,8]," +
+ "\"words\":[\"quick\",\"brown\",\"fox\"]," +
+ "\"ndArray\":{" +
+ "\"appose_type\":\"ndarray\"," +
+ "\"dtype\":\"float32\"," +
+ "\"shape\":[2,20,25]," +
+ "\"shm\":{" +
+ "\"appose_type\":\"shm\"," +
+ "\"name\":\"SHM_NAME\"," +
+ "\"size\":4000" +
+ "}" +
+ "}" +
+ "}";
+
+ private static final String STRING = "-=[]\\;',./_+{}|:\"<>?" +
+ "AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz" +
+ "~!@#$%^&*()";
+
+ private static final int[] NUMBERS = {1, 1, 2, 3, 5, 8};
+
+ private static final String[] WORDS = {"quick", "brown", "fox"};
+
+ @Test
+ public void testEncode() {
+ Map data = new LinkedHashMap<>();
+ data.put("posByte", (byte) 123);
+ data.put("negByte", (byte) -98);
+ data.put("posDouble", 9.876543210123456);
+ data.put("negDouble", -1.234567890987654E302);
+ data.put("posFloat", 9.876543f);
+ data.put("negFloat", -1.2345678f);
+ data.put("posInt", 1234567890);
+ data.put("negInt", -987654321);
+ data.put("posLong", 12345678987654321L);
+ data.put("negLong", -98765432123456789L);
+ data.put("posShort", (short) 32109);
+ data.put("negShort", (short) -23456);
+ data.put("trueBoolean", true);
+ data.put("falseBoolean", false);
+ data.put("aChar", '\0');
+ data.put("aString", STRING);
+ data.put("numbers", NUMBERS);
+ data.put("words", WORDS);
+ NDArray.DType dtype = NDArray.DType.FLOAT32;
+ NDArray.Shape shape = new NDArray.Shape(NDArray.Shape.Order.C_ORDER, 2, 20, 25);
+ try (NDArray ndArray = new NDArray(dtype, shape)) {
+ data.put("ndArray", ndArray);
+ String json = Types.encode(data);
+ assertNotNull(json);
+ String expected = JSON.replaceAll("SHM_NAME", ndArray.shm().name());
+ assertEquals(expected, json);
+ }
+ }
+
+ @Test
+ public void testDecode() {
+ Map data;
+ String shmName;
+
+ // Create name shared memory segment and decode JSON block.
+ try (SharedMemory shm = SharedMemory.create(null, 4000)) {
+ shmName = shm.name();
+ data = Types.decode(JSON.replaceAll("SHM_NAME", shmName));
+ }
+
+ // Validate results.
+ assertNotNull(data);
+ assertEquals(19, data.size());
+ assertEquals(123, data.get("posByte")); // NB: decodes back to int
+ assertEquals(-98, data.get("negByte")); // NB: decodes back to int
+ assertEquals(9.876543210123456, bd(data.get("posDouble")).doubleValue());
+ assertEquals(-1.234567890987654E302, bd(data.get("negDouble")).doubleValue());
+ assertEquals(9.876543f, bd(data.get("posFloat")).floatValue());
+ assertEquals(-1.2345678f, bd(data.get("negFloat")).floatValue());
+ assertEquals(1234567890, data.get("posInt"));
+ assertEquals(-987654321, data.get("negInt"));
+ assertEquals(12345678987654321L, data.get("posLong"));
+ assertEquals(-98765432123456789L, data.get("negLong"));
+ assertEquals(32109, data.get("posShort")); // NB: decodes back to int
+ assertEquals(-23456, data.get("negShort")); // NB: decodes back to int
+ assertEquals(true, data.get("trueBoolean"));
+ assertEquals(false, data.get("falseBoolean"));
+ assertEquals("\0", data.get("aChar"));
+ assertEquals(STRING, data.get("aString"));
+ List numbersList = Arrays.stream(NUMBERS)
+ .boxed()
+ .collect(Collectors.toList());
+ assertEquals(numbersList, data.get("numbers"));
+ assertEquals(Arrays.asList(WORDS), data.get("words"));
+ try (NDArray ndArray = (NDArray) data.get("ndArray")) {
+ assertSame(NDArray.DType.FLOAT32, ndArray.dType());
+ assertEquals(NDArray.Shape.Order.C_ORDER, ndArray.shape().order());
+ assertEquals(3, ndArray.shape().length());
+ assertEquals(2, ndArray.shape().get(0));
+ assertEquals(20, ndArray.shape().get(1));
+ assertEquals(25, ndArray.shape().get(2));
+ assertEquals(shmName, ndArray.shm().name());
+ assertEquals(4000, ndArray.shm().size());
+ }
+ }
+
+ private BigDecimal bd(Object posDouble) {
+ if (posDouble instanceof BigDecimal) return ((BigDecimal) posDouble);
+ throw new IllegalArgumentException("Not a BigDecimal: " + posDouble.getClass().getName());
+ }
+}