wip: memory pool and manager framework

Author: Pengzna

hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/memory/MemoryManager.java

@@ -1,11 +1,88 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 org.apache.hugegraph.memory;
 
+import java.util.Set;
+import java.util.concurrent.CopyOnWriteArraySet;
+import java.util.concurrent.atomic.AtomicLong;
+
+import org.apache.hugegraph.memory.allocator.AbstractAllocator;
+import org.apache.hugegraph.memory.allocator.IMemoryAllocator;
+import org.apache.hugegraph.memory.arbitrator.IMemoryArbitrator;
+import org.apache.hugegraph.memory.arbitrator.MemoryArbitrator;
 import org.apache.hugegraph.memory.pool.IMemoryPool;
-import org.apache.hugegraph.memory.pool.impl.RootMemoryPool;
+import org.apache.hugegraph.memory.pool.impl.QueryMemoryPool;
 
 public class MemoryManager {
 
-    private static final String ROOT_POOL_NAME = "RootQueryMemoryPool";
-    private static final IMemoryPool ROOT = new RootMemoryPool(null, ROOT_POOL_NAME);
+    private static final String QUERY_MEMORY_POOL_NAME_PREFIX = "QueryMemoryPool";
+    private static final String DELIMINATOR = "_";
+    // TODO: read it from conf, current 1G
+    private final AtomicLong currentMemoryCapacityInBytes = new AtomicLong(1000_000_000);
+    private final Set<IMemoryPool> queryMemoryPools = new CopyOnWriteArraySet<>();
+    private final IMemoryArbitrator memoryArbitrator;
+    // TODO: implement different allocate strategy.
+    private final IMemoryAllocator memoryAllocator;
+    // TODO: integrated with mingzhen's monitor thread
+    // private final Runnable queryGCThread;
+
+    private MemoryManager() {
+        this.memoryArbitrator = new MemoryArbitrator();
+        this.memoryAllocator = new AbstractAllocator() {
+            @Override
+            public long tryToAllocateOffHeap(long size) {
+                return 0;
+            }
+
+            @Override
+            public long forceAllocateOffHeap(long size) {
+                return 0;
+            }
+        };
+    }
+
+    public IMemoryPool addQueryMemoryPool() {
+        int count = queryMemoryPools.size();
+        String poolName =
+                QUERY_MEMORY_POOL_NAME_PREFIX + DELIMINATOR + count + DELIMINATOR +
+                System.currentTimeMillis();
+        IMemoryPool queryPool = new QueryMemoryPool(poolName, this);
+        queryMemoryPools.add(queryPool);
+        return queryPool;
+    }
+
+    public void gcQueryMemoryPool(IMemoryPool pool) {
+        queryMemoryPools.remove(pool);
+        long reclaimedMemory = pool.getAllocatedBytes();
+        pool.releaseSelf();
+        currentMemoryCapacityInBytes.addAndGet(reclaimedMemory);
+    }
+
+    private static class MemoryManagerHolder {
+
+        private static final MemoryManager INSTANCE = new MemoryManager();
+
+        private MemoryManagerHolder() {
+            // empty constructor
+        }
+    }
 
+    public static MemoryManager getInstance() {
+        return MemoryManagerHolder.INSTANCE;
+    }
 }

hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/memory/allocator/AbstractAllocator.java

@@ -1,6 +1,23 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 org.apache.hugegraph.memory.allocator;
 
-public abstract class AbstractAllocator implements IAllocator {
+public abstract class AbstractAllocator implements IMemoryAllocator {
 
     @Override
     public long tryToAllocateOnHeap(long size) {

hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/memory/allocator/IAllocator.java

@@ -0,0 +1,30 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 org.apache.hugegraph.memory.allocator;
+
+// TODO(pjz): implement different memory allocate strategy.
+public interface IMemoryAllocator {
+
+    long tryToAllocateOnHeap(long size);
+
+    long forceAllocateOnHeap(long size);
+
+    long tryToAllocateOffHeap(long size);
+
+    long forceAllocateOffHeap(long size);
+}

hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/memory/allocator/IMemoryAllocator.java

@@ -1,3 +1,20 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 org.apache.hugegraph.memory.arbitrator;
 
 public interface IMemoryArbitrator {

hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/memory/arbitrator/IMemoryArbitrator.java

@@ -0,0 +1,22 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 org.apache.hugegraph.memory.arbitrator;
+
+public class MemoryArbitrator implements IMemoryArbitrator {
+
+}

hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/memory/arbitrator/MemoryArbitrator.java

@@ -1,5 +1,23 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 org.apache.hugegraph.memory.consumer;
 
+// TODO(pjz): integrated it with HG objects such as edges and vertex.
 public interface IMemoryConsumer {
 
 }

hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/memory/consumer/IMemoryConsumer.java

@@ -1,20 +1,97 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 org.apache.hugegraph.memory.pool;
 
 import java.util.Set;
-import java.util.concurrent.CopyOnWriteArraySet;
+import java.util.TreeSet;
 
 import org.apache.hugegraph.memory.pool.impl.MemoryPoolStats;
 
 public abstract class AbstractMemoryPool implements IMemoryPool {
-    private final IMemoryPool parent;
-    private final Set<IMemoryPool> children = new CopyOnWriteArraySet<>();
-    private final MemoryPoolStats stats;
+
+    private final Set<IMemoryPool> children =
+            new TreeSet<>((o1, o2) -> (int) (o2.getFreeBytes() - o1.getFreeBytes()));
+    private IMemoryPool parent;
+    private MemoryPoolStats stats;
 
     public AbstractMemoryPool(IMemoryPool parent, String memoryPoolName) {
         this.parent = parent;
         this.stats = new MemoryPoolStats(memoryPoolName);
     }
 
+    @Override
+    public long tryToReclaimLocalMemory(long neededBytes) {
+        long totalReclaimedBytes = 0;
+        long currentNeededBytes = neededBytes;
+        try {
+            for (IMemoryPool child : this.children) {
+                long reclaimedMemory = child.tryToReclaimLocalMemory(currentNeededBytes);
+                if (reclaimedMemory > 0) {
+                    currentNeededBytes -= reclaimedMemory;
+                    totalReclaimedBytes += reclaimedMemory;
+                    // Reclaim enough memory.
+                    if (currentNeededBytes <= 0) {
+                        break;
+                    }
+                }
+            }
+            return totalReclaimedBytes;
+        } finally {
+            this.stats.setNumShrinks(this.stats.getNumShrinks() + 1);
+            this.stats.setAllocatedBytes(
+                    this.stats.getAllocatedBytes() - totalReclaimedBytes);
+        }
+    }
+
+    @Override
+    public void releaseSelf() {
+        try {
+            for (IMemoryPool child : this.children) {
+                child.releaseSelf();
+            }
+        } finally {
+            // Make these objs be GCed by JVM quickly.
+            this.stats = null;
+            this.parent = null;
+            this.children.clear();
+        }
+    }
+
+    @Override
+    public long getMaxCapacityBytes() {
+        return stats.getMaxCapacity();
+    }
+
+    @Override
+    public long getUsedBytes() {
+        return stats.getUsedBytes();
+    }
+
+    @Override
+    public long getFreeBytes() {
+        return stats.getAllocatedBytes() - stats.getUsedBytes();
+    }
+
+    @Override
+    public long getAllocatedBytes() {
+        return stats.getAllocatedBytes();
+    }
+
     @Override
     public MemoryPoolStats getSnapShot() {
         return stats;

hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/memory/pool/AbstractMemoryPool.java

@@ -1,3 +1,20 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 org.apache.hugegraph.memory.pool;
 
 import java.util.Set;
@@ -8,19 +25,29 @@ public interface IMemoryPool {
 
     MemoryPoolStats getSnapShot();
 
+    long tryToReclaimLocalMemory(long neededBytes);
+
+    long tryToAcquireMemory(long bytes);
+
+    void releaseSelf();
+
+    boolean tryToDiskSpill();
+
+    long getAllocatedBytes();
+
+    long getUsedBytes();
+
+    long getFreeBytes();
+
+    long getMaxCapacityBytes();
+
     String getName();
 
     IMemoryPool getParentPool();
 
     Set<IMemoryPool> getChildrenPools();
 
-    long allocate(long bytes);
-
-    long free(long bytes);
-
     long requestMemory(long bytes);
 
     long reclaimMemory(long bytes, long maxWaitMs);
-
-    // visitChildren，传递方法引用
 }