[IGNORE] Homework3

src/main/java/ru/vk/itmo/podobaalexandr/InMemoryDaoImpl.java

@@ -0,0 +1,85 @@
+package ru.vk.itmo.podobaalexandr;
+
+import ru.vk.itmo.Config;
+import ru.vk.itmo.Dao;
+import ru.vk.itmo.Entry;
+
+import java.lang.foreign.MemorySegment;
+import java.nio.file.Path;
+import java.util.Collection;
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.concurrent.ConcurrentNavigableMap;
+import java.util.concurrent.ConcurrentSkipListMap;
+
+public class InMemoryDaoImpl implements Dao<MemorySegment, Entry<MemorySegment>> {
+
+    private static final Comparator<MemorySegment> comparator = MemorySegmentUtils::compare;
+
+    private final ConcurrentNavigableMap<MemorySegment, Entry<MemorySegment>> memorySegmentEntryMap
+            = new ConcurrentSkipListMap<>(comparator);
+
+    private final SSTableWriter ssTableWriter;
+
+    private final SSTableReader ssTableReader;
+
+    public InMemoryDaoImpl() {
+       this(new Config(Path.of("standard")));
+    }
+
+    public InMemoryDaoImpl(Config config) {
+        ssTableReader = new SSTableReader(config.basePath());
+        ssTableWriter = new SSTableWriter(config.basePath(), ssTableReader.size());
+    }
+
+    @Override
+    public Iterator<Entry<MemorySegment>> get(MemorySegment from, MemorySegment to) {
+        ConcurrentNavigableMap<MemorySegment, Entry<MemorySegment>> innerMap = memorySegmentEntryMap;
+        Collection<Entry<MemorySegment>> entries;
+
+        if (from == null && to == null) {
+            entries = ssTableReader.allPages(innerMap);
+        } else if (from == null) {
+            innerMap = innerMap.headMap(to);
+            entries = ssTableReader.allPagesTo(to, innerMap);
+        } else if (to == null) {
+            innerMap = innerMap.tailMap(from);
+            entries = ssTableReader.allPagesFrom(from, innerMap);
+        } else {
+            innerMap = innerMap.subMap(from, to);
+            entries = ssTableReader.allPagesFromTo(from, to, innerMap);
+        }
+
+        entries.removeIf(it -> it.value() == null);
+        return entries.iterator();
+    }
+
+    @Override
+    public void upsert(Entry<MemorySegment> entry) {
+        memorySegmentEntryMap.put(entry.key(), entry);
+    }
+
+    @Override
+    public void close() {
+        if (ssTableReader.isArenaPresented()) {
+            if (!ssTableReader.isAlive()) {
+                return;
+            }
+
+            ssTableReader.close();
+        }
+
+        ssTableWriter.save(memorySegmentEntryMap.values());
+    }
+
+    @Override
+    public Entry<MemorySegment> get(MemorySegment key) {
+        if (memorySegmentEntryMap.containsKey(key)) {
+            Entry<MemorySegment> entry = memorySegmentEntryMap.get(key);
+            return entry.value() == null ? null : entry;
+        }
+
+        return ssTableReader.get(key);
+    }
+
+}

src/main/java/ru/vk/itmo/podobaalexandr/MemorySegmentUtils.java

@@ -0,0 +1,73 @@
+package ru.vk.itmo.podobaalexandr;
+
+import ru.vk.itmo.BaseEntry;
+import ru.vk.itmo.Entry;
+
+import java.lang.foreign.MemorySegment;
+import java.lang.foreign.ValueLayout;
+
+public final class MemorySegmentUtils {
+
+    private MemorySegmentUtils() {
+
+    }
+
+    public static int compare(MemorySegment o1, MemorySegment o2) {
+        return compareSegments(o1, o1.byteSize(), o2, 0, o2.byteSize());
+    }
+
+    public static int compareSegments(MemorySegment src, long srcEnd,
+                                      MemorySegment dest, long destOffset, long destEnd) {
+        long destLength = destEnd - destOffset;
+
+        int sizeDiff = Long.compare(srcEnd, destLength);
+
+        if (srcEnd == 0 || destLength == 0) {
+            return sizeDiff;
+        }
+
+        long mismatch = MemorySegment.mismatch(src, 0, srcEnd, dest, destOffset, destEnd);
+
+        if (mismatch == destLength || mismatch == srcEnd) {
+            return sizeDiff;
+        }
+
+        return mismatch == -1
+                ? 0
+                : Byte.compare(src.get(ValueLayout.JAVA_BYTE, mismatch),
+                dest.get(ValueLayout.JAVA_BYTE, destOffset + mismatch));
+    }
+
+    public static Entry<MemorySegment> getKeyValueFromOffset(MemorySegment page,
+                                                             long offset, long keySize, long keysSize) {
+        long offsetLocal = offset;
+
+        MemorySegment key = page.asSlice(offsetLocal, keySize);
+        offsetLocal += keySize;
+
+        long offsetToV = page.get(ValueLayout.JAVA_LONG_UNALIGNED, offsetLocal);
+
+        if (offsetToV == 0) {
+            return new BaseEntry<>(key, null);
+        }
+
+        offsetLocal += 2 * Long.BYTES + Byte.BYTES;
+        MemorySegment value = null;
+        long size = 0;
+        while (size <= 0 && offsetLocal < keysSize) {
+            long keySizeNextKey = page.get(ValueLayout.JAVA_LONG_UNALIGNED, offsetLocal);
+            offsetLocal += Long.BYTES + keySizeNextKey;
+
+            size = page.get(ValueLayout.JAVA_LONG_UNALIGNED, offsetLocal) - offsetToV;
+            if (size > 0) {
+                value = page.asSlice(offsetToV, size);
+            }
+            offsetLocal += 2 * Long.BYTES + Byte.BYTES;
+        }
+
+        value = value == null ? page.asSlice(offsetToV) : value;
+
+        return new BaseEntry<>(key, value);
+    }
+
+}

src/main/java/ru/vk/itmo/podobaalexandr/SSTable.java

@@ -0,0 +1,227 @@
+package ru.vk.itmo.podobaalexandr;
+
+import ru.vk.itmo.Entry;
+
+import java.io.IOException;
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.foreign.ValueLayout;
+import java.nio.channels.FileChannel;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardOpenOption;
+import java.util.NavigableMap;
+
+public class SSTable {
+
+    private final long keysSize;
+
+    private final MemorySegment page;
+
+    public SSTable(Path file, Arena arena) throws IOException {
+        try (FileChannel fileChannel = FileChannel.open(file, StandardOpenOption.READ)) {
+            long size = Files.size(file);
+            page = fileChannel.map(FileChannel.MapMode.READ_ONLY, 0, size, arena);
+        }
+
+        keysSize = page.get(ValueLayout.JAVA_LONG_UNALIGNED, 0);
+    }
+
+    private boolean isOutOfKeyOffset(long offset) {
+        return keysSize <= offset || offset == 0;
+    }
+
+    //Invariant: FROM < TO
+    public void allPageFromTo(NavigableMap<MemorySegment, Entry<MemorySegment>> entries,
+                               long offset, MemorySegment from, MemorySegment to) {
+        if (isOutOfKeyOffset(offset)) {
+            return;
+        }
+
+        Entry<MemorySegment> last;
+        long offsetLocal = offset;
+
+        long keySize = page.get(ValueLayout.JAVA_LONG_UNALIGNED, offsetLocal);
+        offsetLocal += Long.BYTES;
+
+        int compareFrom = MemorySegmentUtils
+                .compareSegments(from, from.byteSize(), page, offsetLocal, offsetLocal + keySize);
+        int compareTo = MemorySegmentUtils
+                .compareSegments(to, to.byteSize(), page, offsetLocal, offsetLocal + keySize);
+
+        if (compareFrom < 0 && compareTo > 0) {
+            last = MemorySegmentUtils.getKeyValueFromOffset(page, offsetLocal, keySize, keysSize);
+            offsetLocal += keySize + Long.BYTES;
+
+            long offsetToL = page.get(ValueLayout.JAVA_LONG_UNALIGNED, offsetLocal);
+            allPageFrom(entries, offsetToL, from);
+            offsetLocal += Long.BYTES;
+
+            entries.putIfAbsent(last.key(), last);
+
+            byte isRightHere = page.get(ValueLayout.JAVA_BYTE, offsetLocal);
+            long rightOffset = isRightHere == 1 ? offsetLocal + Byte.BYTES : 0;
+            allPageTo(entries, rightOffset, to);
+        } else if (compareFrom == 0) {
+            last = MemorySegmentUtils.getKeyValueFromOffset(page, offsetLocal, keySize, keysSize);
+            offsetLocal += keySize + 2 * Long.BYTES;
+
+            entries.putIfAbsent(last.key(), last);
+            long rightOffset = page.get(ValueLayout.JAVA_BYTE, offsetLocal) == 1 ? offsetLocal + Byte.BYTES : 0;
+            allPageTo(entries, rightOffset, to);
+        } else if (compareTo == 0) {
+            offsetLocal += keySize + Long.BYTES;
+            long offsetToL = page.get(ValueLayout.JAVA_LONG_UNALIGNED, offsetLocal);
+            allPageFrom(entries, offsetToL, from);
+        } else if (compareFrom > 0) {
+            offsetLocal += keySize + 2 * Long.BYTES;
+            long rightOffset = page.get(ValueLayout.JAVA_BYTE, offsetLocal) == 1 ? offsetLocal + Byte.BYTES : 0;
+            allPageFromTo(entries, rightOffset, from, to);
+        } else {
+            offsetLocal += keySize + Long.BYTES;
+            long offsetToL = page.get(ValueLayout.JAVA_LONG_UNALIGNED, offsetLocal);
+            allPageFromTo(entries, offsetToL, from, to);
+        }
+    }
+
+    public void allPageTo(NavigableMap<MemorySegment, Entry<MemorySegment>> entries,
+                           long offset, MemorySegment to) {
+        if (isOutOfKeyOffset(offset)) {
+            return;
+        }
+
+        Entry<MemorySegment> last;
+        long offsetLocal = offset;
+
+        long keySize = page.get(ValueLayout.JAVA_LONG_UNALIGNED, offsetLocal);
+        offsetLocal += Long.BYTES;
+
+        int compare = MemorySegmentUtils
+                .compareSegments(to, to.byteSize(), page, offsetLocal, offsetLocal + keySize);
+
+        if (compare == 0) {
+            offsetLocal += keySize + Long.BYTES;
+
+            long offsetToL = page.get(ValueLayout.JAVA_LONG_UNALIGNED, offsetLocal);
+            allPage(entries, offsetToL);
+        } else if (compare > 0) {
+            last = MemorySegmentUtils.getKeyValueFromOffset(page, offsetLocal, keySize, keysSize);
+            offsetLocal += keySize + Long.BYTES;
+
+            long offsetToL = page.get(ValueLayout.JAVA_LONG_UNALIGNED, offsetLocal);
+            offsetLocal += Long.BYTES;
+
+            allPage(entries, offsetToL);
+
+            entries.putIfAbsent(last.key(), last);
+
+            byte isRightHere = page.get(ValueLayout.JAVA_BYTE, offsetLocal);
+            allPageTo(entries, isRightHere == 1 ? offsetLocal + Byte.BYTES : 0, to);
+        } else {
+            offsetLocal += keySize + Long.BYTES;
+
+            long offsetToL = page.get(ValueLayout.JAVA_LONG_UNALIGNED, offsetLocal);
+            allPageTo(entries, offsetToL, to);
+        }
+    }
+
+    public void allPageFrom(NavigableMap<MemorySegment, Entry<MemorySegment>> entries,
+                            long offset, MemorySegment from) {
+        if (isOutOfKeyOffset(offset)) {
+            return;
+        }
+
+        Entry<MemorySegment> last;
+        long offsetLocal = offset;
+
+        long keySize = page.get(ValueLayout.JAVA_LONG_UNALIGNED, offsetLocal);
+        offsetLocal += Long.BYTES;
+
+        int compare = MemorySegmentUtils
+                .compareSegments(from, from.byteSize(), page, offsetLocal, offsetLocal + keySize);
+
+        if (compare == 0) {
+            last = MemorySegmentUtils.getKeyValueFromOffset(page, offsetLocal, keySize, keysSize);
+            offsetLocal += 2 * Long.BYTES + keySize;
+
+            entries.putIfAbsent(last.key(), last);
+
+            byte isRightHere = page.get(ValueLayout.JAVA_BYTE, offsetLocal);
+            allPage(entries, isRightHere == 1 ? offsetLocal + Byte.BYTES : 0);
+        } else if (compare > 0) {
+            offsetLocal += keySize + 2 * Long.BYTES;
+            byte isRightHere = page.get(ValueLayout.JAVA_BYTE, offsetLocal);
+            allPageFrom(entries, isRightHere == 1 ? offsetLocal + Byte.BYTES : 0, from);
+        } else {
+            last = MemorySegmentUtils.getKeyValueFromOffset(page, offsetLocal, keySize, keysSize);
+            offsetLocal += keySize + Long.BYTES;
+
+            long offsetToL = page.get(ValueLayout.JAVA_LONG_UNALIGNED, offsetLocal);
+            allPageFrom(entries, offsetToL, from);
+            offsetLocal += Long.BYTES;
+
+            entries.putIfAbsent(last.key(), last);
+
+            byte isRightHere = page.get(ValueLayout.JAVA_BYTE, offsetLocal);
+            allPage(entries, isRightHere == 1 ? offsetLocal + Byte.BYTES : 0);
+        }
+    }
+
+    public void allPage(NavigableMap<MemorySegment, Entry<MemorySegment>> entries, long offset) {
+        if (isOutOfKeyOffset(offset)) {
+            return;
+        }
+
+        Entry<MemorySegment> last;
+        long offsetLocal = offset;
+
+        long keySize = page.get(ValueLayout.JAVA_LONG_UNALIGNED, offsetLocal);
+        offsetLocal += Long.BYTES;
+
+        last = MemorySegmentUtils.getKeyValueFromOffset(page, offsetLocal, keySize, keysSize);
+
+        offsetLocal += keySize + Long.BYTES;
+        long offsetToL = page.get(ValueLayout.JAVA_LONG_UNALIGNED, offsetLocal);
+        allPage(entries, offsetToL);
+
+        entries.putIfAbsent(last.key(), last);
+
+        offsetLocal += Long.BYTES;
+        byte isRightHere = page.get(ValueLayout.JAVA_BYTE, offsetLocal);
+        allPage(entries, isRightHere == 1 ? offsetLocal + Byte.BYTES : 0);
+    }
+
+    public Entry<MemorySegment> getFromPage(MemorySegment keySearch) {
+        long offset = Long.BYTES;
+        Entry<MemorySegment> res = null;
+
+        while (offset < keysSize) {
+            long keySize = page.get(ValueLayout.JAVA_LONG_UNALIGNED, offset);
+            offset += Long.BYTES;
+
+            int compare = MemorySegmentUtils
+                    .compareSegments(keySearch, keySearch.byteSize(), page, offset, offset + keySize);
+
+            if (compare == 0) {
+                res = MemorySegmentUtils.getKeyValueFromOffset(page, offset, keySize, keysSize);
+                break;
+            } else if (compare > 0) {
+                offset += keySize + 2 * Long.BYTES;
+                byte isRightExist = page.get(ValueLayout.JAVA_BYTE, offset);
+                if (isRightExist == 0) {
+                    return null;
+                }
+                offset += Byte.BYTES;
+            } else {
+                offset += keySize + Long.BYTES;
+                offset = page.get(ValueLayout.JAVA_LONG_UNALIGNED, offset);
+                if (offset == 0) {
+                    return null;
+                }
+            }
+        }
+
+        return res;
+    }
+
+}