Okay, I have some new code in place that hopefully should work better. I

couldn't produce a full patch using cvs diff -c this time since I have
created new files and anonymous cvs usage doesn't allow you to
adds. I'm supplying the modified src/interfaces/jdbc as a tarball at :
http://www.candleweb.no/~gunnar/projects/pgsql/postgres-jdbc-2000-10-05.tgz

The new files that should be added are :

? org/postgresql/PGStatement.java
? org/postgresql/ObjectPool.java
? org/postgresql/ObjectPoolFactory.java

There is now a global static pool of free byte arrays and used byte arrays
connected to a statement object. This is the role of the new PGStatement
class. Access to the global free array is synchronized, while we rely on
the PG_Stream synchronization for the used array.

My measurements show that the perfomance boost on this code is not quite as
big as my last shot, but it is still an improvement. Maybe some of the
difference is due to the new synchronization on the global array. I think I
will look into choosing between on a connection level and global level.

I have also started experimented with improving the performance of the
various conversions. The problem here is ofcourse related handle the
various encodings. One thing I found to speed up ResultSet.getInt() a lot
was to do custom conversion on the byte array into int instead of going
through the getString() to do the conversion. But I'm unsure if this is
portable, can we assume that a digit never can be represented by more than
one byte ? It works fine in my iso-latin-8859-1 environment, but what about
other environments ? Maybe we could provide different ResultSet
implementations depending on the encoding used or delegate some methods of
the result set to an "converter class".

Check the org/postgresql/jdbc2/FastResultSet.java in the tarball above to
see the modified getInt() method.

Regards,

        Gunnar

1 files changed, 86 insertions, 0 deletions

diff --git a/src/interfaces/jdbc/org/postgresql/ObjectPool.java b/src/interfaces/jdbc/org/postgresql/ObjectPool.java
new file mode 100644
index 0000000000..8ab4506c21
--- /dev/null
+++ b/src/interfaces/jdbc/org/postgresql/ObjectPool.java
@@ -0,0 +1,86 @@
+package org.postgresql;
+
+/**
+ * A simple and fast object pool implementation that can pool objects 
+ * of any type. This implementation is not thread safe, it is up to the users
+ * of this class to assure thread safety. 
+ */
+public class ObjectPool {
+    int cursize = 0;
+    int maxsize = 8;
+    Object arr[] = new Object[8];
+    
+    /**
+     * Add object to the pool.
+     * @param o The object to add.
+     */
+    public void add(Object o){
+	if(cursize >= maxsize){
+	    Object newarr[] = new Object[maxsize*2];
+	    System.arraycopy(arr, 0, newarr, 0, maxsize);
+	    maxsize = maxsize * 2;
+	    arr = newarr;
+	}
+	arr[cursize++] = o;
+    }
+    
+    /**
+     * Remove an object from the pool. If the pool is empty
+     * ArrayIndexOutOfBoundsException will be thrown.
+     * @return Returns the removed object.
+     * @exception If the pool is empty 
+     *            ArrayIndexOutOfBoundsException will be thrown.
+     */
+    public Object remove(){
+	Object o = arr[cursize-1];
+	// This have to be here, so we don't decrease the counter when
+	// cursize == 0;
+	cursize--;
+	return o;
+    }
+
+    /**
+     * Check if pool is empty.
+     * @return true if pool is empty, false otherwise.
+     */
+    public boolean isEmpty(){
+	return cursize == 0;
+    }
+    
+    /**
+     * Get the size of the pool.
+     * @return Returns the number of objects in the pool.
+     */
+    public int size(){
+	return cursize;
+    }
+    /**
+     * Add all the objects from another pool to this pool.
+     * @pool The pool to add the objects from.
+     */
+    public void addAll(ObjectPool pool){
+	int srcsize = pool.size();
+	if(srcsize == 0)
+	    return;
+	int totalsize = srcsize + cursize;
+	if(totalsize > maxsize){
+	    Object newarr[] = new Object[totalsize*2];
+	    System.arraycopy(arr, 0, newarr, 0, cursize);
+	    maxsize = maxsize = totalsize * 2;
+	    arr = newarr;
+	}
+	System.arraycopy(pool.arr, 0, arr, cursize, srcsize);
+	cursize = totalsize;
+    }
+
+    /**
+     * Clear the elements from this pool.
+     * The method is lazy, so it just resets the index counter without
+     * removing references to pooled objects. This could possibly 
+     * be an issue with garbage collection, depending on how the 
+     * pool is used.
+     */
+    public void clear(){
+	cursize = 0;
+    }
+}