[jffi-next] 11/49: Allocate native method struct memory out of one chunk of memory

[Tim Potter]

This is an automated email from the git hooks/post-receive script.

tpot-guest pushed a commit to annotated tag upstream/1.0.10
in repository jffi-next.

commit 65e8ac15ad8a922a357361d975153652b205ff5f
Author: Wayne Meissner <wmeissner at gmail.com>
Date:   Tue Jan 4 20:56:59 2011 +1000

    Allocate native method struct memory out of one chunk of memory
---
 src/com/kenai/jffi/NativeMethod.java  | 36 ++----------------
 src/com/kenai/jffi/NativeMethods.java | 71 +++++++++++++++++++++++++----------
 2 files changed, 55 insertions(+), 52 deletions(-)

diff --git a/src/com/kenai/jffi/NativeMethod.java b/src/com/kenai/jffi/NativeMethod.java
index 91d1566..65c2902 100644
--- a/src/com/kenai/jffi/NativeMethod.java
+++ b/src/com/kenai/jffi/NativeMethod.java
@@ -22,10 +22,9 @@ package com.kenai.jffi;
  * Represents a native implementation of a method for a class
  */
 public final class NativeMethod {
-    private final MemoryIO io = MemoryIO.getInstance();
     final long function;
-    final long name;
-    final long signature;
+    final String name;
+    final String signature;
 
     /**
      * Creates a new native method wrapper.
@@ -36,34 +35,7 @@ public final class NativeMethod {
      */
     public NativeMethod(long address, String name, String signature) {
         this.function = address;
-        this.name = nativeString(io, name);
-        this.signature = nativeString(io, signature);
-    }
-
-    private static final long nativeString(MemoryIO io, String s) {
-        byte[] bytes = s.getBytes();
-
-        long memory = io.allocateMemory(bytes.length + 1, false);
-        if (memory == 0L) {
-            throw new OutOfMemoryError("failed to allocate memory for string");
-        }
-
-        io.putZeroTerminatedByteArray(memory, bytes, 0, bytes.length);
-
-        return memory;
-    }
-
-    @Override
-    protected void finalize() throws Throwable {
-        try {
-            if (name != 0L) {
-                io.freeMemory(name);
-            }
-            if (signature != 0L) {
-                io.freeMemory(signature);
-            }
-        } finally {
-            super.finalize();
-        }
+        this.name = name;
+        this.signature = signature;
     }
 }
diff --git a/src/com/kenai/jffi/NativeMethods.java b/src/com/kenai/jffi/NativeMethods.java
index b773ef9..89eaa79 100644
--- a/src/com/kenai/jffi/NativeMethods.java
+++ b/src/com/kenai/jffi/NativeMethods.java
@@ -22,6 +22,8 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 import java.util.WeakHashMap;
+import java.util.logging.Level;
+import java.util.logging.Logger;
 
 /**
  * Utility class to register native methods on a class
@@ -38,14 +40,10 @@ public final class NativeMethods {
     private static final Map<Class, NativeMethods> registeredMethods
             = new WeakHashMap<Class, NativeMethods>();
 
-    private final long memory;
-    private final List<NativeMethod> methods;
-    private final MemoryIO mm;
+    private final ResourceHolder memory;
 
-    private NativeMethods(MemoryIO mm, long memory, List<NativeMethod> methods) {
-        this.mm = mm;
+    private NativeMethods(ResourceHolder memory) {
         this.memory = memory;
-        this.methods = new ArrayList<NativeMethod>(methods);
     }
 
     /**
@@ -55,7 +53,16 @@ public final class NativeMethods {
      * @param methods The list of methods to attach to the class.
      */
     public static synchronized final void register(Class clazz, List<NativeMethod> methods) {
-        final long ptrSize = Platform.getPlatform().addressSize() / 8;
+        //
+        // Calculate how much memory is needed for the function names + signatures
+        //
+        int stringSize = 0;
+        for (NativeMethod m : methods) {
+            stringSize += m.name.getBytes().length + 1;
+            stringSize += m.signature.getBytes().length + 1;
+        }
+
+        final int ptrSize = Platform.getPlatform().addressSize() / 8;
         final MemoryIO mm = MemoryIO.getInstance();
 
         //
@@ -66,18 +73,29 @@ public final class NativeMethods {
         //      char *signature;
         //      void *fnPtr;
         //   } JNINativeMethod;
-
-        long memory = mm.allocateMemory(methods.size() * 3 * ptrSize, true);
+        int structSize = methods.size() * 3 * ptrSize;
+        long memory = mm.allocateMemory(structSize + stringSize, true);
         if (memory == 0L) {
             throw new OutOfMemoryError("could not allocate native memory");
         }
 
-        NativeMethods nm = new NativeMethods(mm, memory, methods);
+        NativeMethods nm = new NativeMethods(new ResourceHolder(mm, memory));
 
-        long off = 0;
+        int off = 0;
+        int stringOff = structSize;
         for (NativeMethod m : methods) {
-            mm.putAddress(memory + off, m.name); off += ptrSize;
-            mm.putAddress(memory + off, m.signature); off += ptrSize;
+            byte[] name = m.name.getBytes();
+            long nameAddress = memory + stringOff;
+            stringOff += name.length + 1;
+            mm.putZeroTerminatedByteArray(nameAddress, name, 0, name.length);
+            
+            byte[] sig = m.signature.getBytes();
+            long sigAddress = memory + stringOff;
+            stringOff += sig.length + 1;
+            mm.putZeroTerminatedByteArray(sigAddress, sig, 0, sig.length);
+            
+            mm.putAddress(memory + off, nameAddress); off += ptrSize;
+            mm.putAddress(memory + off, sigAddress); off += ptrSize;
             mm.putAddress(memory + off, m.function); off += ptrSize;
         }
 
@@ -104,13 +122,26 @@ public final class NativeMethods {
         
         registeredMethods.remove(clazz);
     }
-
-    @Override
-    protected void finalize() throws Throwable {
-        try {
-            mm.freeMemory(memory);
-        } finally {
-            super.finalize();
+    
+    private static final class ResourceHolder {
+        private final MemoryIO mm;
+        private final long memory;
+
+        public ResourceHolder(MemoryIO mm, long memory) {
+            this.mm = mm;
+            this.memory = memory;
+        }
+        
+        @Override
+        protected void finalize() throws Throwable {
+            try {
+                mm.freeMemory(memory);
+            } catch (Throwable t) {
+                Logger.getLogger(getClass().getName()).log(Level.WARNING, 
+                    "Exception when freeing native method struct array: %s", t.getLocalizedMessage());
+            } finally {
+                super.finalize();
+            }
         }
     }
 }

-- 
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/pkg-java/jffi-next.git