Собственная производительность в стиле C / C ++ для сериализации объектов Java

Вы когда-нибудь хотели бы превратить объект Java в поток байтов так быстро, как это можно сделать на родном языке, таком как C ++? Если вы используете стандартную сериализацию Java, вы можете быть разочарованы производительностью. Java Serialization была разработана для совершенно иной цели, чем сериализация объектов настолько быстро и компактно, насколько это возможно.

Зачем нам нужна быстрая и компактная сериализация? Многие из наших систем распределены, и нам нужно обмениваться информацией, эффективно передавая состояние между процессами. Это состояние живет внутри наших объектов. Я профилировал многие системы, и часто большая часть затрат заключается в сериализации этого состояния в байтовые буферы. Я видел значительный спектр протоколов и механизмов, используемых для достижения этой цели. На одном конце спектра находятся простые в использовании, но неэффективные протоколы, такие как Java Serialization , XML и JSON . На другом конце этого спектра находятся бинарные протоколы, которые могут быть очень быстрыми и эффективными, но они требуют более глубокого понимания и навыков.

В этой статье я проиллюстрирую прирост производительности, который возможен при использовании простых двоичных протоколов, и познакомлю вас с малоизвестной техникой, доступной в Java, для достижения производительности, аналогичной той, которая возможна с родными языками, такими как C или C ++.

Три подхода для сравнения:

Сериализация Java : стандартный метод в Java для реализации объекта в Serializable .
Двоичный через ByteBuffer : простой протокол, использующий API ByteBuffer для записи полей объекта в двоичном формате. Это наша основа для того, что считается хорошим подходом двоичного кодирования.
Двоичные через Unsafe : Введение в Unsafe и его набор методов, которые позволяют напрямую манипулировать памятью. Здесь я покажу, как получить аналогичную производительность C / C ++.

Код

import sun.misc.Unsafe;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.lang.reflect.Field;
import java.nio.ByteBuffer;
import java.util.Arrays;
 
public final class TestSerialisationPerf
{
    public static final int REPETITIONS = 1 * 1000 * 1000;
 
    private static ObjectToBeSerialised ITEM =
        new ObjectToBeSerialised(
            1010L, true, 777, 99,
            new double[]{0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0},
            new long[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10});
 
 
    public static void main(final String[] arg) throws Exception
    {
        for (final PerformanceTestCase testCase : testCases)
        {
            for (int i = 0; i < 5; i++)
            {
                testCase.performTest();
 
                System.out.format('%d %s\twrite=%,dns read=%,dns total=%,dns\n',
                                  i,
                                  testCase.getName(),
                                  testCase.getWriteTimeNanos(),
                                  testCase.getReadTimeNanos(),
                                  testCase.getWriteTimeNanos() + 
                                  testCase.getReadTimeNanos());
 
                if (!ITEM.equals(testCase.getTestOutput()))
                {
                    throw new IllegalStateException('Objects do not match');
                }
 
                System.gc();
                Thread.sleep(3000);
            }
        }
    }
 
    private static final PerformanceTestCase[] testCases =
    {
        new PerformanceTestCase('Serialisation', REPETITIONS, ITEM)
        {
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
 
            public void testWrite(ObjectToBeSerialised item) throws Exception
            {
                for (int i = 0; i < REPETITIONS; i++)
                {
                    baos.reset();
 
                    ObjectOutputStream oos = new ObjectOutputStream(baos);
                    oos.writeObject(item);
                    oos.close();
                }
            }
 
            public ObjectToBeSerialised testRead() throws Exception
            {
                ObjectToBeSerialised object = null;
                for (int i = 0; i < REPETITIONS; i++)
                {
                    ByteArrayInputStream bais = 
                        new ByteArrayInputStream(baos.toByteArray());
                    ObjectInputStream ois = new ObjectInputStream(bais);
                    object = (ObjectToBeSerialised)ois.readObject();
                }
 
                return object;
            }
        },
 
        new PerformanceTestCase('ByteBuffer', REPETITIONS, ITEM)
        {
            ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
 
            public void testWrite(ObjectToBeSerialised item) throws Exception
            {
                for (int i = 0; i < REPETITIONS; i++)
                {
                    byteBuffer.clear();
                    item.write(byteBuffer);
                }
            }
 
            public ObjectToBeSerialised testRead() throws Exception
            {
                ObjectToBeSerialised object = null;
                for (int i = 0; i < REPETITIONS; i++)
                {
                    byteBuffer.flip();
                    object = ObjectToBeSerialised.read(byteBuffer);
                }
 
                return object;
            }
        },
 
        new PerformanceTestCase('UnsafeMemory', REPETITIONS, ITEM)
        {
            UnsafeMemory buffer = new UnsafeMemory(new byte[1024]);
 
            public void testWrite(ObjectToBeSerialised item) throws Exception
            {
                for (int i = 0; i < REPETITIONS; i++)
                {
                    buffer.reset();
                    item.write(buffer);
                }
            }
 
            public ObjectToBeSerialised testRead() throws Exception
            {
                ObjectToBeSerialised object = null;
                for (int i = 0; i < REPETITIONS; i++)
                {
                    buffer.reset();
                    object = ObjectToBeSerialised.read(buffer);
                }
 
                return object;
            }
        },
    };
}
 
abstract class PerformanceTestCase
{
    private final String name;
    private final int repetitions;
    private final ObjectToBeSerialised testInput;
    private ObjectToBeSerialised testOutput;
    private long writeTimeNanos;
    private long readTimeNanos;
 
    public PerformanceTestCase(final String name, final int repetitions,
                               final ObjectToBeSerialised testInput)
    {
        this.name = name;
        this.repetitions = repetitions;
        this.testInput = testInput;
    }
 
    public String getName()
    {
        return name;
    }
 
    public ObjectToBeSerialised getTestOutput()
    {
        return testOutput;
    }
 
    public long getWriteTimeNanos()
    {
        return writeTimeNanos;
    }
 
    public long getReadTimeNanos()
    {
        return readTimeNanos;
    }
 
    public void performTest() throws Exception
    {
        final long startWriteNanos = System.nanoTime();
        testWrite(testInput);
        writeTimeNanos = (System.nanoTime() - startWriteNanos) / repetitions;
 
        final long startReadNanos = System.nanoTime();
        testOutput = testRead();
        readTimeNanos = (System.nanoTime() - startReadNanos) / repetitions;
    }
 
    public abstract void testWrite(ObjectToBeSerialised item) throws Exception;
    public abstract ObjectToBeSerialised testRead() throws Exception;
}
 
class ObjectToBeSerialised implements Serializable
{
    private static final long serialVersionUID = 10275539472837495L;
 
    private final long sourceId;
    private final boolean special;
    private final int orderCode;
    private final int priority;
    private final double[] prices;
    private final long[] quantities;
 
    public ObjectToBeSerialised(final long sourceId, final boolean special,
                                final int orderCode, final int priority,
                                final double[] prices, final long[] quantities)
    {
        this.sourceId = sourceId;
        this.special = special;
        this.orderCode = orderCode;
        this.priority = priority;
        this.prices = prices;
        this.quantities = quantities;
    }
 
    public void write(final ByteBuffer byteBuffer)
    {
        byteBuffer.putLong(sourceId);
        byteBuffer.put((byte)(special ? 1 : 0));
        byteBuffer.putInt(orderCode);
        byteBuffer.putInt(priority);
 
        byteBuffer.putInt(prices.length);
        for (final double price : prices)
        {
            byteBuffer.putDouble(price);
        }
 
        byteBuffer.putInt(quantities.length);
        for (final long quantity : quantities)
        {
            byteBuffer.putLong(quantity);
        }
    }
 
    public static ObjectToBeSerialised read(final ByteBuffer byteBuffer)
    {
        final long sourceId = byteBuffer.getLong();
        final boolean special = 0 != byteBuffer.get();
        final int orderCode = byteBuffer.getInt();
        final int priority = byteBuffer.getInt();
 
        final int pricesSize = byteBuffer.getInt();
        final double[] prices = new double[pricesSize];
        for (int i = 0; i < pricesSize; i++)
        {
            prices[i] = byteBuffer.getDouble();
        }
 
        final int quantitiesSize = byteBuffer.getInt();
        final long[] quantities = new long[quantitiesSize];
        for (int i = 0; i < quantitiesSize; i++)
        {
            quantities[i] = byteBuffer.getLong();
        }
 
        return new ObjectToBeSerialised(sourceId, special, orderCode, 
                                        priority, prices, quantities);
    }
 
    public void write(final UnsafeMemory buffer)
    {
        buffer.putLong(sourceId);
        buffer.putBoolean(special);
        buffer.putInt(orderCode);
        buffer.putInt(priority);
        buffer.putDoubleArray(prices);
        buffer.putLongArray(quantities);
    }
 
    public static ObjectToBeSerialised read(final UnsafeMemory buffer)
    {
        final long sourceId = buffer.getLong();
        final boolean special = buffer.getBoolean();
        final int orderCode = buffer.getInt();
        final int priority = buffer.getInt();
        final double[] prices = buffer.getDoubleArray();
        final long[] quantities = buffer.getLongArray();
 
        return new ObjectToBeSerialised(sourceId, special, orderCode, 
                                        priority, prices, quantities);
    }
 
    @Override
    public boolean equals(final Object o)
    {
        if (this == o)
        {
            return true;
        }
        if (o == null || getClass() != o.getClass())
        {
            return false;
        }
 
        final ObjectToBeSerialised that = (ObjectToBeSerialised)o;
 
        if (orderCode != that.orderCode)
        {
            return false;
        }
        if (priority != that.priority)
        {
            return false;
        }
        if (sourceId != that.sourceId)
        {
            return false;
        }
        if (special != that.special)
        {
            return false;
        }
        if (!Arrays.equals(prices, that.prices))
        {
            return false;
        }
        if (!Arrays.equals(quantities, that.quantities))
        {
            return false;
        }
 
        return true;
    }
}
 
class UnsafeMemory
{
    private static final Unsafe unsafe;
    static
    {
        try
        {
            Field field = Unsafe.class.getDeclaredField('theUnsafe');
            field.setAccessible(true);
            unsafe = (Unsafe)field.get(null);
        }
        catch (Exception e)
        {
            throw new RuntimeException(e);
        }
    }
 
    private static final long byteArrayOffset = unsafe.arrayBaseOffset(byte[].class);
    private static final long longArrayOffset = unsafe.arrayBaseOffset(long[].class);
    private static final long doubleArrayOffset = unsafe.arrayBaseOffset(double[].class);
 
    private static final int SIZE_OF_BOOLEAN = 1;
    private static final int SIZE_OF_INT = 4;
    private static final int SIZE_OF_LONG = 8;
 
    private int pos = 0;
    private final byte[] buffer;
 
    public UnsafeMemory(final byte[] buffer)
    {
        if (null == buffer)
        {
            throw new NullPointerException('buffer cannot be null');
        }
 
        this.buffer = buffer;
    }
 
    public void reset()
    {
        this.pos = 0;
    }
 
    public void putBoolean(final boolean value)
    {
        unsafe.putBoolean(buffer, byteArrayOffset + pos, value);
        pos += SIZE_OF_BOOLEAN;
    }
 
    public boolean getBoolean()
    {
        boolean value = unsafe.getBoolean(buffer, byteArrayOffset + pos);
        pos += SIZE_OF_BOOLEAN;
 
        return value;
    }
 
    public void putInt(final int value)
    {
        unsafe.putInt(buffer, byteArrayOffset + pos, value);
        pos += SIZE_OF_INT;
    }
 
    public int getInt()
    {
        int value = unsafe.getInt(buffer, byteArrayOffset + pos);
        pos += SIZE_OF_INT;
 
        return value;
    }
 
    public void putLong(final long value)
    {
        unsafe.putLong(buffer, byteArrayOffset + pos, value);
        pos += SIZE_OF_LONG;
    }
 
    public long getLong()
    {
        long value = unsafe.getLong(buffer, byteArrayOffset + pos);
        pos += SIZE_OF_LONG;
 
        return value;
    }
 
    public void putLongArray(final long[] values)
    {
        putInt(values.length);
 
        long bytesToCopy = values.length << 3;
        unsafe.copyMemory(values, longArrayOffset,
                          buffer, byteArrayOffset + pos,
                          bytesToCopy);
        pos += bytesToCopy;
    }
 
    public long[] getLongArray()
    {
        int arraySize = getInt();
        long[] values = new long[arraySize];
 
        long bytesToCopy = values.length << 3;
        unsafe.copyMemory(buffer, byteArrayOffset + pos,
                          values, longArrayOffset,
                          bytesToCopy);
        pos += bytesToCopy;
 
        return values;
    }
 
    public void putDoubleArray(final double[] values)
    {
        putInt(values.length);
 
        long bytesToCopy = values.length << 3;
        unsafe.copyMemory(values, doubleArrayOffset,
                          buffer, byteArrayOffset + pos,
                          bytesToCopy);
        pos += bytesToCopy;
    }
 
    public double[] getDoubleArray()
    {
        int arraySize = getInt();
        double[] values = new double[arraySize];
 
        long bytesToCopy = values.length << 3;
        unsafe.copyMemory(buffer, byteArrayOffset + pos,
                          values, doubleArrayOffset,
                          bytesToCopy);
        pos += bytesToCopy;
 
        return values;
    }
}

Полученные результаты

8GHz Nehalem - Java 1.7.0_04
==============================
Serialisation  write=2,517ns read=11,570ns total=14,087ns
Serialisation  write=2,198ns read=11,122ns total=13,320ns
Serialisation  write=2,190ns read=11,011ns total=13,201ns
Serialisation  write=2,221ns read=10,972ns total=13,193ns
Serialisation  write=2,187ns read=10,817ns total=13,004ns
ByteBuffer     write=264ns   read=273ns    total=537ns
ByteBuffer     write=248ns   read=243ns    total=491ns
ByteBuffer     write=262ns   read=243ns    total=505ns
ByteBuffer     write=300ns   read=240ns    total=540ns
ByteBuffer     write=247ns   read=243ns    total=490ns
UnsafeMemory   write=99ns    read=84ns     total=183ns
UnsafeMemory   write=53ns    read=82ns     total=135ns
UnsafeMemory   write=63ns    read=66ns     total=129ns
UnsafeMemory   write=46ns    read=63ns     total=109ns
UnsafeMemory   write=48ns    read=58ns     total=106ns
 
4GHz Sandy Bridge - Java 1.7.0_04
===================================
Serialisation  write=1,940ns read=9,006ns total=10,946ns
Serialisation  write=1,674ns read=8,567ns total=10,241ns
Serialisation  write=1,666ns read=8,680ns total=10,346ns
Serialisation  write=1,666ns read=8,623ns total=10,289ns
Serialisation  write=1,715ns read=8,586ns total=10,301ns
ByteBuffer     write=199ns   read=198ns   total=397ns
ByteBuffer     write=176ns   read=178ns   total=354ns
ByteBuffer     write=174ns   read=174ns   total=348ns
ByteBuffer     write=172ns   read=183ns   total=355ns
ByteBuffer     write=174ns   read=180ns   total=354ns
UnsafeMemory   write=38ns    read=75ns    total=113ns
UnsafeMemory   write=26ns    read=52ns    total=78ns
UnsafeMemory   write=26ns    read=51ns    total=77ns
UnsafeMemory   write=25ns    read=51ns    total=76ns
UnsafeMemory   write=27ns    read=50ns    total=77ns

Анализ

Для записи и считывания одного относительно небольшого объекта на моем быстром ноутбуке с процессором Sandy Bridge с частотой 2,4 ГГц может потребоваться ~ 10 000 нс с использованием Java-сериализации, тогда как при использовании Unsafe это может доходить до менее 100 нс даже с учетом самого тестового кода. Чтобы поместить это в контекст, при использовании Java Serialization затраты равны сетевому переходу! Теперь это будет очень дорого, если ваш транспорт — это быстрый механизм IPC в той же системе.

Существует множество причин, по которым Java-сериализация стоит так дорого. Например, он записывает полные имена классов и полей для каждого объекта, а также информацию о версии. Также ObjectOutputStream хранит коллекцию всех записанных объектов, чтобы их можно было сопоставлять при вызове close (). Сериализация Java требует 340 байтов для этого примера объекта, но нам требуется только 185 байтов для двоичных версий. Подробности о формате сериализации Java можно найти здесь . Если бы я не использовал массивы для большинства данных, то сериализованный объект был бы значительно больше с сериализацией Java из-за имен полей. По моему опыту текстовые протоколы, такие как XML и JSON, могут быть даже менее эффективными, чем сериализация Java. Также имейте в виду, что Java Serialization является стандартным механизмом, используемым для RMI .

Настоящая проблема заключается в количестве выполняемых инструкций. Небезопасный метод выигрывает с большим отрывом, потому что в Hotspot и многих других JVM оптимизатор рассматривает эти операции как внутренние и заменяет вызов инструкциями по сборке для выполнения манипуляций с памятью. Для примитивных типов это приводит к одной инструкции x86 MOV, которая часто может происходить за один цикл. Детали можно увидеть, если Hotspot выведет оптимизированный код, как я описал в предыдущей статье .

Теперь нужно сказать, что « с большой силой приходит большая ответственность », и если вы используете Unsafe, это фактически то же самое, что программирование на C, и с этим могут происходить нарушения доступа к памяти, когда вы получаете неправильные смещения.

Добавление некоторого контекста

«А как насчет буферов протокола Google ?» — слышу вы. Это очень полезные библиотеки, которые часто предлагают лучшую производительность и большую гибкость, чем сериализация Java. Тем не менее, они не очень близко к производительности использования Unsafe, как я показал здесь. Протоколные буферы решают другую проблему и предоставляют хорошие сообщения с самоописанием, которые хорошо работают на разных языках. Пожалуйста, протестируйте с различными протоколами и методами сериализации, чтобы сравнить результаты.

Также проницательный из вас будет спрашивать: «А как насчет порядка байтов написанных целых чисел?» С Unsafe байты пишутся в собственном порядке. Это отлично подходит для IPC и между системами одного типа. Когда системы используют разные форматы, тогда потребуется преобразование.

Как мы имеем дело с несколькими версиями класса или определяем, к какому классу принадлежит объект? Я хочу сосредоточить внимание на этой статье, но, скажем, простое целое число, указывающее, что класс реализации — это все, что требуется для заголовка. Это целое число может использоваться для поиска соответствующей реализации для операции десериализации.

Аргумент, который я часто слышу против двоичных протоколов и текстовых протоколов, это как насчет того, чтобы быть читаемым человеком и отлаженным? Существует простое решение для этого. Разработайте инструмент для чтения двоичного формата!

Вывод

В заключение можно достичь того же самого уровня C / C ++, как и уровни производительности в Java, для сериализации объекта в поток байтов и из него, эффективно используя те же методы. Класс UnsafeMemory, для которого я предоставил каркасную реализацию, можно легко расширить, чтобы инкапсулировать это поведение и таким образом защитить себя от многих потенциальных проблем при работе с таким острым инструментом.

Теперь для насущного вопроса. Не было бы намного лучше, если бы Java предложила альтернативный интерфейс Marshallable для Serializable , предлагая изначально то, что я эффективно сделал с Unsafe ???

Ссылка: родная производительность в стиле C / C ++ для сериализации объектов Java от нашего партнера по JCG Мартина Томпсона из блога Mechanical Sympathy

Собственная производительность в стиле C / C ++ для сериализации объектов Java

Категории

Последние статьи

Рефакторинг Hudson God Class

Альтернативы синтаксиса Java лямбда

Morphia и MongoDB: развивающиеся структуры документов

OpenShift Express: развертывание приложения Java EE (с поддержкой AS7)

Интеграция jqGrid, REST, AJAX и Spring MVC