From a2f58ccccf52039db5dbfa2de19ad89623643973 Mon Sep 17 00:00:00 2001
From: "Brian S. O'Neill" <bronee@gmail.com>
Date: Sun, 4 May 2008 17:36:39 +0000
Subject: Merged map repository implementation from map branch.

---
 .../amazon/carbonado/repo/map/TestLockStates.java  | 314 +++++++++++++++++++++
 .../amazon/carbonado/repo/map/TestLockStress.java  | 161 +++++++++++
 .../carbonado/repo/map/TestRWLockStress.java       | 133 +++++++++
 .../amazon/carbonado/repo/map/TestStorables.java   |  97 +++++++
 4 files changed, 705 insertions(+)
 create mode 100644 src/test/java/com/amazon/carbonado/repo/map/TestLockStates.java
 create mode 100644 src/test/java/com/amazon/carbonado/repo/map/TestLockStress.java
 create mode 100644 src/test/java/com/amazon/carbonado/repo/map/TestRWLockStress.java
 create mode 100644 src/test/java/com/amazon/carbonado/repo/map/TestStorables.java

(limited to 'src')

diff --git a/src/test/java/com/amazon/carbonado/repo/map/TestLockStates.java b/src/test/java/com/amazon/carbonado/repo/map/TestLockStates.java
new file mode 100644
index 0000000..4450179
--- /dev/null
+++ b/src/test/java/com/amazon/carbonado/repo/map/TestLockStates.java
@@ -0,0 +1,314 @@
+/*
+ * Copyright 2007 Amazon Technologies, Inc. or its affiliates.
+ * Amazon, Amazon.com and Carbonado are trademarks or registered trademarks
+ * of Amazon Technologies, Inc. or its affiliates.  All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.amazon.carbonado.repo.map;
+
+import java.util.concurrent.TimeUnit;
+
+/**
+ * 
+ *
+ * @author Brian S O'Neill
+ */
+public class TestLockStates {
+    private static void lockForRead(UpgradableLock lock, TestLockStates locker) {
+        //System.out.println("read lock");
+        lock.lockForRead(locker);
+        //System.out.println(lock);
+    }
+
+    private static void unlockFromRead(UpgradableLock lock, TestLockStates locker) {
+        //System.out.println("read unlock");
+        lock.unlockFromRead(locker);
+        //System.out.println(lock);
+    }
+
+    private static void lockForUpgrade(UpgradableLock lock, TestLockStates locker) {
+        //System.out.println("upgrade lock");
+        lock.lockForUpgrade(locker);
+        //System.out.println(lock);
+    }
+
+    private static void unlockFromUpgrade(UpgradableLock lock, TestLockStates locker) {
+        //System.out.println("upgrade unlock");
+        lock.unlockFromUpgrade(locker);
+        //System.out.println(lock);
+    }
+
+    private static void lockForWrite(UpgradableLock lock, TestLockStates locker)
+        throws InterruptedException
+    {
+        //System.out.println("write lock");
+        lock.lockForWriteInterruptibly(locker);
+        //System.out.println(lock);
+    }
+
+    private static boolean tryLockForWrite(UpgradableLock lock, TestLockStates locker, int timeout)
+        throws InterruptedException
+    {
+        //System.out.println("write lock");
+        boolean result = lock.tryLockForWrite(locker, timeout, TimeUnit.MILLISECONDS);
+        //System.out.println(lock);
+        return result;
+    }
+
+    private static void unlockFromWrite(UpgradableLock lock, TestLockStates locker) {
+        //System.out.println("write unlock");
+        lock.unlockFromWrite(locker);
+        //System.out.println(lock);
+    }
+
+    public static void main(String[] args) throws Exception {
+        UpgradableLock lock = new UpgradableLock();
+        TestLockStates locker = new TestLockStates();
+        TestLockStates locker2 = new TestLockStates();
+
+        /*
+        final Thread main = Thread.currentThread();
+
+        new Thread() {
+            public void run() {
+                try {
+                    Thread.sleep(5000);
+                } catch (InterruptedException e) {
+                }
+                main.interrupt();
+            }
+        }.start();
+        */
+
+        System.out.println("0 ----------------------");
+        System.out.println(lock);
+
+        {
+            // start with no locks
+
+            lockForRead(lock, locker);
+            unlockFromRead(lock, locker);
+
+            lockForUpgrade(lock, locker);
+            unlockFromUpgrade(lock, locker);
+
+            lockForWrite(lock, locker);
+            unlockFromWrite(lock, locker);
+        }
+
+        System.out.println("1 ----------------------");
+        System.out.println(lock);
+
+        {
+            lockForRead(lock, locker);
+
+            lockForRead(lock, locker);
+            unlockFromRead(lock, locker);
+
+            lockForUpgrade(lock, locker);
+            unlockFromUpgrade(lock, locker);
+
+            // should deadlock
+            if (tryLockForWrite(lock, locker, 1000)) {
+                System.out.println("***** did not deadlock!!!");
+                unlockFromWrite(lock, locker);
+            }
+
+            unlockFromRead(lock, locker);
+        }
+
+        System.out.println("2 ----------------------");
+        System.out.println(lock);
+
+        {
+            lockForRead(lock, locker);
+            lockForUpgrade(lock, locker);
+
+            lockForRead(lock, locker);
+            unlockFromRead(lock, locker);
+
+            lockForUpgrade(lock, locker);
+            unlockFromUpgrade(lock, locker);
+
+            // should deadlock
+            if (tryLockForWrite(lock, locker, 1000)) {
+                System.out.println("***** did not deadlock!!!");
+                unlockFromWrite(lock, locker);
+            }
+
+            unlockFromRead(lock, locker);
+            unlockFromUpgrade(lock, locker);
+        }
+
+        System.out.println("3 ----------------------");
+        System.out.println(lock);
+
+        {
+            lockForUpgrade(lock, locker);
+
+            lockForRead(lock, locker);
+            unlockFromRead(lock, locker);
+
+            lockForUpgrade(lock, locker);
+            unlockFromUpgrade(lock, locker);
+
+            lockForWrite(lock, locker);
+            unlockFromWrite(lock, locker);
+
+            unlockFromUpgrade(lock, locker);
+        }
+
+        System.out.println("4 ----------------------");
+        System.out.println(lock);
+
+        {
+            lockForWrite(lock, locker);
+
+            lockForRead(lock, locker);
+            unlockFromRead(lock, locker);
+
+            lockForUpgrade(lock, locker);
+            unlockFromUpgrade(lock, locker);
+
+            lockForWrite(lock, locker);
+            unlockFromWrite(lock, locker);
+
+            unlockFromWrite(lock, locker);
+        }
+
+        System.out.println("5 ----------------------");
+        System.out.println(lock);
+
+        {
+            lockForWrite(lock, locker);
+            lockForRead(lock, locker);
+
+            lockForRead(lock, locker);
+            unlockFromRead(lock, locker);
+
+            lockForUpgrade(lock, locker);
+            unlockFromUpgrade(lock, locker);
+
+            lockForWrite(lock, locker);
+            unlockFromWrite(lock, locker);
+
+            unlockFromRead(lock, locker);
+            unlockFromWrite(lock, locker);
+        }
+
+        System.out.println("6 ----------------------");
+        System.out.println(lock);
+
+        {
+            lockForWrite(lock, locker);
+            lockForUpgrade(lock, locker);
+            lockForRead(lock, locker);
+
+            lockForRead(lock, locker);
+            unlockFromRead(lock, locker);
+
+            lockForUpgrade(lock, locker);
+            unlockFromUpgrade(lock, locker);
+
+            lockForWrite(lock, locker);
+            unlockFromWrite(lock, locker);
+
+            unlockFromRead(lock, locker);
+            unlockFromUpgrade(lock, locker);
+            unlockFromWrite(lock, locker);
+        }
+
+        System.out.println("7 ----------------------");
+        System.out.println(lock);
+
+        {
+            lockForWrite(lock, locker);
+            lockForUpgrade(lock, locker);
+
+            lockForRead(lock, locker);
+            unlockFromRead(lock, locker);
+
+            lockForUpgrade(lock, locker);
+            lockForUpgrade(lock, locker);
+            unlockFromUpgrade(lock, locker);
+            unlockFromUpgrade(lock, locker);
+
+            lockForWrite(lock, locker);
+            unlockFromWrite(lock, locker);
+
+            unlockFromUpgrade(lock, locker);
+            unlockFromWrite(lock, locker);
+        }
+
+        System.out.println("8 ----------------------");
+        System.out.println(lock);
+
+        {
+            lockForUpgrade(lock, locker);
+            lockForWrite(lock, locker);
+            unlockFromUpgrade(lock, locker);
+            unlockFromWrite(lock, locker);
+        }
+
+        System.out.println("9 ----------------------");
+        System.out.println(lock);
+
+        {
+            lockForUpgrade(lock, locker);
+            lockForWrite(lock, locker);
+            lockForUpgrade(lock, locker);
+            lockForWrite(lock, locker);
+            unlockFromUpgrade(lock, locker);
+            unlockFromWrite(lock, locker);
+            unlockFromUpgrade(lock, locker);
+            unlockFromWrite(lock, locker);
+        }
+
+        System.out.println("10 ----------------------");
+        System.out.println(lock);
+
+        {
+            lockForUpgrade(lock, locker);
+            lockForUpgrade(lock, locker);
+            lockForWrite(lock, locker);
+            lockForWrite(lock, locker);
+            unlockFromUpgrade(lock, locker);
+            unlockFromUpgrade(lock, locker);
+            lockForUpgrade(lock, locker);
+            unlockFromWrite(lock, locker);
+            unlockFromWrite(lock, locker);
+            unlockFromUpgrade(lock, locker);
+        }
+
+        System.out.println("11 ----------------------");
+        System.out.println(lock);
+
+        {
+            lockForWrite(lock, locker);
+            unlockFromUpgrade(lock, locker);
+            try {
+                unlockFromWrite(lock, locker);
+                System.out.println("***** unlocked");
+            } catch (IllegalMonitorStateException e) {
+            }
+        }
+
+        System.out.println("12 ----------------------");
+        System.out.println(lock);
+     }
+
+    public TestLockStates() {
+    }
+}
diff --git a/src/test/java/com/amazon/carbonado/repo/map/TestLockStress.java b/src/test/java/com/amazon/carbonado/repo/map/TestLockStress.java
new file mode 100644
index 0000000..efbe815
--- /dev/null
+++ b/src/test/java/com/amazon/carbonado/repo/map/TestLockStress.java
@@ -0,0 +1,161 @@
+/*
+ * Copyright 2008 Amazon Technologies, Inc. or its affiliates.
+ * Amazon, Amazon.com and Carbonado are trademarks or registered trademarks
+ * of Amazon Technologies, Inc. or its affiliates.  All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.amazon.carbonado.repo.map;
+
+import java.util.*;
+
+/**
+ * 
+ *
+ * @author Brian S O'Neill
+ */
+public class TestLockStress {
+    static long cSharedValue;
+
+    static volatile boolean cStop;
+
+    /**
+     * @param args args[0]: readers, args[1]: upgraders, args[2]: writers, args[3]: run time
+     */
+    public static void main(String[] args) throws Exception {
+        final int readers = Integer.parseInt(args[0]);
+        final int upgraders = Integer.parseInt(args[1]);
+        final int writers = Integer.parseInt(args[2]);
+        final int runTimeSeconds = Integer.parseInt(args[3]);
+
+        final UpgradableLock lock = new UpgradableLock();
+
+        List<TestThread> threads = new ArrayList<TestThread>();
+
+        for (int i=0; i<readers; i++) {
+            TestThread t = new TestThread("reader " + i) {
+                public void run() {
+                    while (!cStop) {
+                        lock.lockForRead(this);
+                        try {
+                            long value = cSharedValue;
+                            // Do some "work"
+                            String.valueOf(value);
+                            long again = cSharedValue;
+                            if (again != value) {
+                                throw new AssertionError("" + again + " != " + value);
+                            }
+                            mReadCount++;
+                        } finally {
+                            lock.unlockFromRead(this);
+                        }
+                    }
+                }
+            };
+            threads.add(t);
+            t.start();
+        }
+
+        for (int i=0; i<upgraders; i++) {
+            TestThread t = new TestThread("upgrader " + i) {
+                public void run() {
+                    while (!cStop) {
+                        lock.lockForUpgrade(this);
+                        try {
+                            long value = cSharedValue;
+                            // Do some "work"
+                            String.valueOf(value);
+                            assert(cSharedValue == value);
+                            lock.lockForWrite(this);
+                            assert(cSharedValue == value);
+                            try {
+                                cSharedValue = value + 1;
+                            } finally {
+                                lock.unlockFromWrite(this);
+                            }
+                            mAdjustCount++;
+                        } finally {
+                            lock.unlockFromUpgrade(this);
+                        }
+                    }
+                }
+            };
+            threads.add(t);
+            t.start();
+        }
+
+        for (int i=0; i<writers; i++) {
+            TestThread t = new TestThread("writer " + i) {
+                public void run() {
+                    while (!cStop) {
+                        lock.lockForWrite(this);
+                        try {
+                            long value = cSharedValue;
+                            // Do some "work"
+                            String.valueOf(value);
+                            assert(cSharedValue == value);
+                            cSharedValue = value + 1;
+                            mAdjustCount++;
+                        } finally {
+                            lock.unlockFromWrite(this);
+                        }
+                    }
+                }
+            };
+            threads.add(t);
+            t.start();
+        }
+
+        Thread.sleep(1000L * runTimeSeconds);
+        cStop = true;
+
+        for (TestThread t : threads) {
+            t.join();
+        }
+
+        long reads = 0;
+        for (TestThread t : threads) {
+            reads += t.mReadCount;
+        }
+
+        long expected = 0;
+        for (TestThread t : threads) {
+            expected += t.mAdjustCount;
+        }
+
+        System.out.println("Reads:    " + reads);
+        System.out.println("Expected: " + expected);
+        System.out.println("Actual:   " + cSharedValue);
+
+        if (expected == cSharedValue) {
+            System.out.println("SUCCESS");
+        } else {
+            System.out.println("FAILURE");
+        }
+
+        System.out.println();
+        for (TestThread t : threads) {
+            System.out.println(t.mReadCount + ", " + t.mAdjustCount);
+        }
+    }
+
+    private abstract static class TestThread extends Thread {
+        long mReadCount;
+        long mAdjustCount;
+
+        TestThread(String name) {
+            super(name);
+        }
+    }
+}
diff --git a/src/test/java/com/amazon/carbonado/repo/map/TestRWLockStress.java b/src/test/java/com/amazon/carbonado/repo/map/TestRWLockStress.java
new file mode 100644
index 0000000..f6bb485
--- /dev/null
+++ b/src/test/java/com/amazon/carbonado/repo/map/TestRWLockStress.java
@@ -0,0 +1,133 @@
+/*
+ * Copyright 2007 Amazon Technologies, Inc. or its affiliates.
+ * Amazon, Amazon.com and Carbonado are trademarks or registered trademarks
+ * of Amazon Technologies, Inc. or its affiliates.  All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.amazon.carbonado.repo.map;
+
+import java.util.*;
+import java.util.concurrent.locks.*;
+
+/**
+ * 
+ *
+ * @author Brian S O'Neill
+ */
+public class TestRWLockStress {
+    static long cSharedValue;
+
+    static volatile boolean cStop;
+
+    /**
+     * @param args args[0]: readers, args[1]: upgraders, args[2]: writers, args[3]: run time
+     */
+    public static void main(String[] args) throws Exception {
+        final int readers = Integer.parseInt(args[0]);
+        final int writers = Integer.parseInt(args[2]);
+        final int runTimeSeconds = Integer.parseInt(args[3]);
+
+        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(args[1].equals("f"));
+
+        List<TestThread> threads = new ArrayList<TestThread>();
+
+        for (int i=0; i<readers; i++) {
+            TestThread t = new TestThread("reader " + i) {
+                public void run() {
+                    while (!cStop) {
+                        lock.readLock().lock();
+                        try {
+                            long value = cSharedValue;
+                            // Do some "work"
+                            String.valueOf(value);
+                            long again = cSharedValue;
+                            if (again != value) {
+                                throw new AssertionError("" + again + " != " + value);
+                            }
+                            mReadCount++;
+                        } finally {
+                            lock.readLock().unlock();
+                        }
+                    }
+                }
+            };
+            threads.add(t);
+            t.start();
+        }
+
+        for (int i=0; i<writers; i++) {
+            TestThread t = new TestThread("writer " + i) {
+                public void run() {
+                    while (!cStop) {
+                        lock.writeLock().lock();
+                        try {
+                            long value = cSharedValue;
+                            // Do some "work"
+                            String.valueOf(value);
+                            assert(cSharedValue == value);
+                            cSharedValue = value + 1;
+                            mAdjustCount++;
+                        } finally {
+                            lock.writeLock().unlock();
+                        }
+                    }
+                }
+            };
+            threads.add(t);
+            t.start();
+        }
+
+        Thread.sleep(1000L * runTimeSeconds);
+        cStop = true;
+
+        for (TestThread t : threads) {
+            t.join();
+        }
+
+        long reads = 0;
+        for (TestThread t : threads) {
+            reads += t.mReadCount;
+        }
+
+        long expected = 0;
+        for (TestThread t : threads) {
+            expected += t.mAdjustCount;
+        }
+
+        System.out.println("Reads:    " + reads);
+        System.out.println("Expected: " + expected);
+        System.out.println("Actual:   " + cSharedValue);
+
+        if (expected == cSharedValue) {
+            System.out.println("SUCCESS");
+        } else {
+            System.out.println("FAILURE");
+        }
+
+        System.out.println();
+        for (TestThread t : threads) {
+            System.out.println(t.mReadCount + ", " + t.mAdjustCount);
+        }
+    }
+
+    private abstract static class TestThread extends Thread {
+        long mReadCount;
+        long mAdjustCount;
+
+        TestThread(String name) {
+            super(name);
+        }
+    }
+}
diff --git a/src/test/java/com/amazon/carbonado/repo/map/TestStorables.java b/src/test/java/com/amazon/carbonado/repo/map/TestStorables.java
new file mode 100644
index 0000000..8210ca9
--- /dev/null
+++ b/src/test/java/com/amazon/carbonado/repo/map/TestStorables.java
@@ -0,0 +1,97 @@
+/*
+ * Copyright 2008 Amazon Technologies, Inc. or its affiliates.
+ * Amazon, Amazon.com and Carbonado are trademarks or registered trademarks
+ * of Amazon Technologies, Inc. or its affiliates.  All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.amazon.carbonado.repo.map;
+
+import junit.framework.TestSuite;
+
+import org.joda.time.DateTime;
+import org.joda.time.DateTimeZone;
+
+import com.amazon.carbonado.Repository;
+import com.amazon.carbonado.RepositoryBuilder;
+import com.amazon.carbonado.RepositoryException;
+import com.amazon.carbonado.Query;
+import com.amazon.carbonado.Storage;
+
+import com.amazon.carbonado.stored.StorableDateIndex;
+
+/**
+ *
+ *
+ * @author Brian S O'Neill
+ */
+public class TestStorables extends com.amazon.carbonado.TestStorables {
+    public static void main(String[] args) {
+        junit.textui.TestRunner.run(suite());
+    }
+
+    public static TestSuite suite() {
+        TestSuite suite = new TestSuite();
+        suite.addTestSuite(TestStorables.class);
+        return suite;
+    }
+
+    public TestStorables(String name) {
+        super(name);
+    }
+
+    @Override
+    public void test_invalidStorables() {
+        // Map repository has no problem with custom property types.
+    }
+
+    @Override
+    public void test_dateTimeIndex() throws Exception {
+        // Map repository does not use DateTimeAdapter.
+
+        Storage<StorableDateIndex> storage = getRepository().storageFor(StorableDateIndex.class);
+
+        DateTimeZone original = DateTimeZone.getDefault();
+        // Set time zone different than defined in storable.
+        DateTimeZone.setDefault(DateTimeZone.forID("America/Los_Angeles"));
+        try {
+            DateTime now = new DateTime();
+
+            StorableDateIndex sdi = storage.prepare();
+            sdi.setID(1);
+            sdi.setOrderDate(now);
+            sdi.insert();
+
+            sdi.load();
+
+            assertEquals(now.getMillis(), sdi.getOrderDate().getMillis());
+            // Time zones are equal since there's no adapter.
+            assertTrue(now.equals(sdi.getOrderDate()));
+
+            Query<StorableDateIndex> query = storage.query("orderDate=?").with(now);
+            StorableDateIndex sdi2 = query.tryLoadOne();
+            assertNotNull(sdi2);
+        } finally {
+            DateTimeZone.setDefault(original);
+        }
+    }
+
+    @Override
+    protected Repository buildRepository(boolean isMaster) throws RepositoryException {
+        MapRepositoryBuilder builder = new MapRepositoryBuilder();
+        builder.setName("map");
+        builder.setMaster(isMaster);
+        return builder.build();
+    }
+}
-- 
cgit v1.2.3