All Downloads are FREE. Search and download functionalities are using the official Maven repository.

org.apache.cassandra.utils.FastByteOperations Maven / Gradle / Ivy

There is a newer version: 3.11.12.3
Show newest version
/*
 * 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.cassandra.utils;

import java.lang.reflect.Field;
import java.nio.Buffer;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.security.AccessController;
import java.security.PrivilegedAction;

import com.google.common.primitives.*;

import net.nicoulaj.compilecommand.annotations.Inline;
import sun.misc.Unsafe;

/**
 * Utility code to do optimized byte-array comparison.
 * This is borrowed and slightly modified from Guava's {@link UnsignedBytes}
 * class to be able to compare arrays that start at non-zero offsets.
 */
public class FastByteOperations
{

    /**
     * Lexicographically compare two byte arrays.
     */
    public static int compareUnsigned(byte[] b1, int s1, int l1, byte[] b2, int s2, int l2)
    {
        return BestHolder.BEST.compare(b1, s1, l1, b2, s2, l2);
    }

    public static int compareUnsigned(ByteBuffer b1, byte[] b2, int s2, int l2)
    {
        return BestHolder.BEST.compare(b1, b2, s2, l2);
    }

    public static int compareUnsigned(byte[] b1, int s1, int l1, ByteBuffer b2)
    {
        return -BestHolder.BEST.compare(b2, b1, s1, l1);
    }

    public static int compareUnsigned(ByteBuffer b1, ByteBuffer b2)
    {
        return BestHolder.BEST.compare(b1, b2);
    }

    public static void copy(ByteBuffer src, int srcPosition, byte[] trg, int trgPosition, int length)
    {
        BestHolder.BEST.copy(src, srcPosition, trg, trgPosition, length);
    }

    public static void copy(ByteBuffer src, int srcPosition, ByteBuffer trg, int trgPosition, int length)
    {
        BestHolder.BEST.copy(src, srcPosition, trg, trgPosition, length);
    }

    public interface ByteOperations
    {
        abstract public int compare(byte[] buffer1, int offset1, int length1,
                                    byte[] buffer2, int offset2, int length2);

        abstract public int compare(ByteBuffer buffer1, byte[] buffer2, int offset2, int length2);

        abstract public int compare(ByteBuffer buffer1, ByteBuffer buffer2);

        abstract public void copy(ByteBuffer src, int srcPosition, byte[] trg, int trgPosition, int length);

        abstract public void copy(ByteBuffer src, int srcPosition, ByteBuffer trg, int trgPosition, int length);
    }

    /**
     * Provides a lexicographical comparer implementation; either a Java
     * implementation or a faster implementation based on {@link Unsafe}.
     * 

*

Uses reflection to gracefully fall back to the Java implementation if * {@code Unsafe} isn't available. */ private static class BestHolder { static final String UNSAFE_COMPARER_NAME = FastByteOperations.class.getName() + "$UnsafeOperations"; static final ByteOperations BEST = getBest(); /** * Returns the Unsafe-using Comparer, or falls back to the pure-Java * implementation if unable to do so. */ static ByteOperations getBest() { if (!Architecture.IS_UNALIGNED) return new PureJavaOperations(); try { Class theClass = Class.forName(UNSAFE_COMPARER_NAME); // yes, UnsafeComparer does implement Comparer @SuppressWarnings("unchecked") ByteOperations comparer = (ByteOperations) theClass.getConstructor().newInstance(); return comparer; } catch (Throwable t) { JVMStabilityInspector.inspectThrowable(t); // ensure we really catch *everything* return new PureJavaOperations(); } } } @SuppressWarnings("unused") // used via reflection public static final class UnsafeOperations implements ByteOperations { static final Unsafe theUnsafe; /** * The offset to the first element in a byte array. */ static final long BYTE_ARRAY_BASE_OFFSET; static final long DIRECT_BUFFER_ADDRESS_OFFSET; static { theUnsafe = (Unsafe) AccessController.doPrivileged( new PrivilegedAction() { @Override public Object run() { try { Field f = Unsafe.class.getDeclaredField("theUnsafe"); f.setAccessible(true); return f.get(null); } catch (NoSuchFieldException e) { // It doesn't matter what we throw; // it's swallowed in getBest(). throw new Error(); } catch (IllegalAccessException e) { throw new Error(); } } }); try { BYTE_ARRAY_BASE_OFFSET = theUnsafe.arrayBaseOffset(byte[].class); DIRECT_BUFFER_ADDRESS_OFFSET = theUnsafe.objectFieldOffset(Buffer.class.getDeclaredField("address")); } catch (Exception e) { throw new AssertionError(e); } // sanity check - this should never fail if (theUnsafe.arrayIndexScale(byte[].class) != 1) { throw new AssertionError(); } } static final boolean BIG_ENDIAN = ByteOrder.nativeOrder().equals(ByteOrder.BIG_ENDIAN); public int compare(byte[] buffer1, int offset1, int length1, byte[] buffer2, int offset2, int length2) { return compareTo(buffer1, BYTE_ARRAY_BASE_OFFSET + offset1, length1, buffer2, BYTE_ARRAY_BASE_OFFSET + offset2, length2); } public int compare(ByteBuffer buffer1, byte[] buffer2, int offset2, int length2) { Object obj1; long offset1; if (buffer1.hasArray()) { obj1 = buffer1.array(); offset1 = BYTE_ARRAY_BASE_OFFSET + buffer1.arrayOffset(); } else { obj1 = null; offset1 = theUnsafe.getLong(buffer1, DIRECT_BUFFER_ADDRESS_OFFSET); } int length1; { int position = buffer1.position(); int limit = buffer1.limit(); length1 = limit - position; offset1 += position; } return compareTo(obj1, offset1, length1, buffer2, BYTE_ARRAY_BASE_OFFSET + offset2, length2); } public int compare(ByteBuffer buffer1, ByteBuffer buffer2) { return compareTo(buffer1, buffer2); } public void copy(ByteBuffer src, int srcPosition, byte[] trg, int trgPosition, int length) { if (src.hasArray()) System.arraycopy(src.array(), src.arrayOffset() + srcPosition, trg, trgPosition, length); else copy(null, srcPosition + theUnsafe.getLong(src, DIRECT_BUFFER_ADDRESS_OFFSET), trg, trgPosition, length); } public void copy(ByteBuffer srcBuf, int srcPosition, ByteBuffer trgBuf, int trgPosition, int length) { Object src; long srcOffset; if (srcBuf.hasArray()) { src = srcBuf.array(); srcOffset = BYTE_ARRAY_BASE_OFFSET + srcBuf.arrayOffset(); } else { src = null; srcOffset = theUnsafe.getLong(srcBuf, DIRECT_BUFFER_ADDRESS_OFFSET); } copy(src, srcOffset + srcPosition, trgBuf, trgPosition, length); } public static void copy(Object src, long srcOffset, ByteBuffer trgBuf, int trgPosition, int length) { if (trgBuf.hasArray()) copy(src, srcOffset, trgBuf.array(), trgBuf.arrayOffset() + trgPosition, length); else copy(src, srcOffset, null, trgPosition + theUnsafe.getLong(trgBuf, DIRECT_BUFFER_ADDRESS_OFFSET), length); } public static void copy(Object src, long srcOffset, byte[] trg, int trgPosition, int length) { if (length <= MIN_COPY_THRESHOLD) { for (int i = 0 ; i < length ; i++) trg[trgPosition + i] = theUnsafe.getByte(src, srcOffset + i); } else { copy(src, srcOffset, trg, BYTE_ARRAY_BASE_OFFSET + trgPosition, length); } } // 1M, copied from java.nio.Bits (unfortunately a package-private class) private static final long UNSAFE_COPY_THRESHOLD = 1 << 20; private static final long MIN_COPY_THRESHOLD = 6; public static void copy(Object src, long srcOffset, Object dst, long dstOffset, long length) { while (length > 0) { long size = (length > UNSAFE_COPY_THRESHOLD) ? UNSAFE_COPY_THRESHOLD : length; // if src or dst are null, the offsets are absolute base addresses: theUnsafe.copyMemory(src, srcOffset, dst, dstOffset, size); length -= size; srcOffset += size; dstOffset += size; } } @Inline public static int compareTo(ByteBuffer buffer1, ByteBuffer buffer2) { Object obj1; long offset1; int length1; if (buffer1.hasArray()) { obj1 = buffer1.array(); offset1 = BYTE_ARRAY_BASE_OFFSET + buffer1.arrayOffset(); } else { obj1 = null; offset1 = theUnsafe.getLong(buffer1, DIRECT_BUFFER_ADDRESS_OFFSET); } offset1 += buffer1.position(); length1 = buffer1.remaining(); return compareTo(obj1, offset1, length1, buffer2); } @Inline public static int compareTo(Object buffer1, long offset1, int length1, ByteBuffer buffer) { Object obj2; long offset2; int position = buffer.position(); int limit = buffer.limit(); if (buffer.hasArray()) { obj2 = buffer.array(); offset2 = BYTE_ARRAY_BASE_OFFSET + buffer.arrayOffset(); } else { obj2 = null; offset2 = theUnsafe.getLong(buffer, DIRECT_BUFFER_ADDRESS_OFFSET); } int length2 = limit - position; offset2 += position; return compareTo(buffer1, offset1, length1, obj2, offset2, length2); } /** * Lexicographically compare two arrays. * * @param buffer1 left operand: a byte[] or null * @param buffer2 right operand: a byte[] or null * @param memoryOffset1 Where to start comparing in the left buffer (pure memory address if buffer1 is null, or relative otherwise) * @param memoryOffset2 Where to start comparing in the right buffer (pure memory address if buffer1 is null, or relative otherwise) * @param length1 How much to compare from the left buffer * @param length2 How much to compare from the right buffer * @return 0 if equal, {@code < 0} if left is less than right, etc. */ @Inline public static int compareTo(Object buffer1, long memoryOffset1, int length1, Object buffer2, long memoryOffset2, int length2) { int minLength = Math.min(length1, length2); /* * Compare 8 bytes at a time. Benchmarking shows comparing 8 bytes at a * time is no slower than comparing 4 bytes at a time even on 32-bit. * On the other hand, it is substantially faster on 64-bit. */ int wordComparisons = minLength & ~7; for (int i = 0; i < wordComparisons ; i += Longs.BYTES) { long lw = theUnsafe.getLong(buffer1, memoryOffset1 + i); long rw = theUnsafe.getLong(buffer2, memoryOffset2 + i); if (lw != rw) { if (BIG_ENDIAN) return UnsignedLongs.compare(lw, rw); return UnsignedLongs.compare(Long.reverseBytes(lw), Long.reverseBytes(rw)); } } for (int i = wordComparisons ; i < minLength ; i++) { int b1 = theUnsafe.getByte(buffer1, memoryOffset1 + i) & 0xFF; int b2 = theUnsafe.getByte(buffer2, memoryOffset2 + i) & 0xFF; if (b1 != b2) return b1 - b2; } return length1 - length2; } } @SuppressWarnings("unused") public static final class PureJavaOperations implements ByteOperations { @Override public int compare(byte[] buffer1, int offset1, int length1, byte[] buffer2, int offset2, int length2) { // Short circuit equal case if (buffer1 == buffer2 && offset1 == offset2 && length1 == length2) return 0; int end1 = offset1 + length1; int end2 = offset2 + length2; for (int i = offset1, j = offset2; i < end1 && j < end2; i++, j++) { int a = (buffer1[i] & 0xff); int b = (buffer2[j] & 0xff); if (a != b) { return a - b; } } return length1 - length2; } public int compare(ByteBuffer buffer1, byte[] buffer2, int offset2, int length2) { if (buffer1.hasArray()) return compare(buffer1.array(), buffer1.arrayOffset() + buffer1.position(), buffer1.remaining(), buffer2, offset2, length2); return compare(buffer1, ByteBuffer.wrap(buffer2, offset2, length2)); } public int compare(ByteBuffer buffer1, ByteBuffer buffer2) { int end1 = buffer1.limit(); int end2 = buffer2.limit(); for (int i = buffer1.position(), j = buffer2.position(); i < end1 && j < end2; i++, j++) { int a = (buffer1.get(i) & 0xff); int b = (buffer2.get(j) & 0xff); if (a != b) { return a - b; } } return buffer1.remaining() - buffer2.remaining(); } public void copy(ByteBuffer src, int srcPosition, byte[] trg, int trgPosition, int length) { if (src.hasArray()) { System.arraycopy(src.array(), src.arrayOffset() + srcPosition, trg, trgPosition, length); return; } src = src.duplicate(); src.position(srcPosition); src.get(trg, trgPosition, length); } public void copy(ByteBuffer src, int srcPosition, ByteBuffer trg, int trgPosition, int length) { if (src.hasArray() && trg.hasArray()) { System.arraycopy(src.array(), src.arrayOffset() + srcPosition, trg.array(), trg.arrayOffset() + trgPosition, length); return; } src = src.duplicate(); src.position(srcPosition).limit(srcPosition + length); trg = trg.duplicate(); trg.position(trgPosition); trg.put(src); } } }