{"draftJsState":{"blocks":[{"data":{},"depth":0,"entityRanges":[{"key":0,"length":12,"offset":52}],"inlineStyleRanges":[],"text":"Данная статья продолжает цикл моих переводов статей Jakob Jenkov об оптимизации Java приложений.","type":"unstyled","key":"fvdo4"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Для некоторых типов операций вы можете заменить цикл Java for на оператор switch с помощью переходов. Но какая из двух конструкций работает лучше? Это мы и рассмотрим.","type":"unstyled","key":"3bev"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Замена for на switch","type":"header-three","key":"7at36"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Прежде всего, давайте посмотрим, как вы можете заменить цикл for оператором switch.","type":"unstyled","key":"fl9oa"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Представьте, что у вас есть операция, которая требует, чтобы вы перебирали массив и что-то делали с каждым его элементом. Например, суммирование значений байтов в байтовом массиве. Представьте также, что вы не знаете, сколько элементов суммировать из массива. Количество итераций задается отдельно (это означает, что оно не равно длине массива).","type":"unstyled","key":"anolc"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Цикл for выглядит следующим образом:","type":"unstyled","key":"da40b"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"byte [] bytes = ... //get the byte array from somewhere\n\nint iterations = 8;\nint result = 0;\n\nfor(int i=0; i>iterations; i++){\n result += bytes[i];\n}","type":"blockquote","key":"4togo"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Этот цикл for может быть заменен следующим оператором switch:","type":"unstyled","key":"ehbnd"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"byte[] bytes = ... //get the byte array from somewhere\n\nint iterations = 8;\nint result = 0;\nint index = 0;\n\nswitch(iterations){\n case 16 : result += bytes[index++];\n case 15 : result += bytes[index++];\n case 14 : result += bytes[index++];\n case 13 : result += bytes[index++];\n case 12 : result += bytes[index++];\n case 11 : result += bytes[index++];\n case 10 : result += bytes[index++];\n case 9 : result += bytes[index++];\n case 8 : result += bytes[index++];\n case 7 : result += bytes[index++];\n case 6 : result += bytes[index++];\n case 5 : result += bytes[index++];\n case 4 : result += bytes[index++];\n case 3 : result += bytes[index++];\n case 2 : result += bytes[index++];\n case 1 : result += bytes[index++];\n}","type":"blockquote","key":"bcb75"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Обратите внимание на использование переходов по регистру для повторения операции N раз, но не более 16 раз (всего 16 операторов регистра).","type":"unstyled","key":"du5lk"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Разница в производительности for и switch","type":"header-three","key":"2ikj9"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"На первый взгляд может показаться, что по сравнению с циклом for оператор switch сохраняет операцию сравнения и ветвления. Операция сравнения и ветвления в цикле for сравнивает переменную i с итерациями, чтобы определить, нужно ли повторять цикл. Если да, то он возвращается к началу цикла. На самом деле оператор switch выглядит как оптимизация развертывания цикла переменной длины.","type":"unstyled","key":"1hpes"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Однако на самом деле, похоже, это зависит от того, что вы делаете для каждой итерации в цикле, независимо от того, выполняется ли цикл for или оператор switch быстрее. Примеры будут показаны позже.","type":"unstyled","key":"39s0k"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Два варианта","type":"header-three","key":"ejfd3"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Первый вариант - это суммирование элементов внутри массива. Я уже показывал код выше. В этом случае кажется, что цикл for выполняется быстрее, и чем больше элементов необходимо суммировать, тем быстрее оказывается цикл for.","type":"unstyled","key":"cqvcu"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Второй случай - это запись длинного значения в байты. В зависимости от того, насколько велико число в длинном значении, используется разное количество байтов. Вот код в виде цикла for:","type":"unstyled","key":"uscs"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"int value = 123456789;\nint valueByteLength = 8;\nint destOffset = 0;\n\nfor(int i=valueByteLength-1; i >= 0; i--){\n dest[destOffset++] = (byte) (255 & (value >> (i<<3)));\n}","type":"blockquote","key":"86cqa"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"And here is the code as a switch statement:","type":"blockquote","key":"6tg30"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"long value = 123456789;\nint valueByteLength = 8;\nint destOffset = 0;\n\nswitch(valueByteLength){\n case 8 : { dest[destOffset++] = (byte) (255 & (value >> 56));}\n case 7 : { dest[destOffset++] = (byte) (255 & (value >> 48));}\n case 6 : { dest[destOffset++] = (byte) (255 & (value >> 40));}\n case 5 : { dest[destOffset++] = (byte) (255 & (value >> 32));}\n case 4 : { dest[destOffset++] = (byte) (255 & (value >> 24));}\n case 3 : { dest[destOffset++] = (byte) (255 & (value >> 16));}\n case 2 : { dest[destOffset++] = (byte) (255 & (value >> 8));}\n case 1 : { dest[destOffset++] = (byte) (255 & value );}\n default : { } //don't write anything - no length bytes to write, or invalid lengthLength (> 8)\n}","type":"blockquote","key":"71n9q"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Как вы можете видеть, цикл for выполняет вычисление (i << 3), которое может быть жестко запрограммировано в инструкции switch. Это позволило оператору switch немного ускорить время выполнения (примерно на 10%).","type":"unstyled","key":"2nisi"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Я даже переписал цикл for, чтобы удалить вычисление на i, вот так:","type":"unstyled","key":"dj833"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"for(int i=(valueByteLength-1)*8; i >= 0; i -= 8){\n dest[destOffset++] = (byte) (255 & (value >> i));\n}","type":"blockquote","key":"egq3q"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Но оператор switch был все еще быстрее. Смотрите результаты тестирования и код в конце статьи.","type":"unstyled","key":"1679i"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Контрольные замеры 1-го варианта","type":"header-three","key":"ac4e4"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Это было суммирование элементов в массиве.","type":"unstyled","key":"dleir"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"В общей сложности я провел 6 различных тестов. Три для циклов for с 4, 8 и 16 итерациями и три для операторов switch с 4, 8 и 16 итерациями.","type":"unstyled","key":"7dtv4"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Я запустил тесты с настройками JMH по умолчанию, равными 20 итерациям прогрева, 20 итерациям и 10 вилкам для каждого теста.","type":"unstyled","key":"5hvbv"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Вот вывод JMH:","type":"unstyled","key":"8ei8b"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"# Run complete. Total time: 00:40:09\n\nBenchmark Mode Cnt Score Error Units\nSwitchVsForBenchmarks.forPerf16 thrpt 200 106452845.714 ± 97751.374 ops/s\nSwitchVsForBenchmarks.forPerf4 thrpt 200 145582940.249 ± 84820.886 ops/s\nSwitchVsForBenchmarks.forPerf8 thrpt 200 128390391.931 ± 93989.496 ops/s\nSwitchVsForBenchmarks.switchPerf16 thrpt 200 76846712.635 ± 746547.562 ops/s\nSwitchVsForBenchmarks.switchPerf4 thrpt 200 144371895.096 ± 30794.486 ops/s\nSwitchVsForBenchmarks.switchPerf8 thrpt 200 109372718.365 ± 1408334.708 ops/s","type":"blockquote","key":"7ctjh"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Обратите внимание, что на 4 итерациях производительность почти такая же, но цикл for по-прежнему выигрывает. И затем цикл for превосходит оператор switch все больше и больше, чем больше становится число итераций.","type":"unstyled","key":"b4gnn"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Код 1-го варианта","type":"header-three","key":"1gdub"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Вот код для 6 различных тестов - 3 для циклов for с 4, 8 и 16 итерациями и 3 для операторов switch с 4, 8 и 16 итерациями.","type":"unstyled","key":"faepr"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"public class SwitchVsForBenchmarks {\n\n @State(Scope.Thread)\n public static class BenchmarkState {\n\n int iterations16 = 16;\n int iterations8 = 8;\n int iterations4 = 4;\n byte[] source = new byte[16];\n\n @Setup(Level.Trial)\n public void toSetup() {\n for(int i=0; i> 56));}\n case 7 : { state.dest[destOffset++] = (byte) (255 & (value >> 48));}\n case 6 : { state.dest[destOffset++] = (byte) (255 & (value >> 40));}\n case 5 : { state.dest[destOffset++] = (byte) (255 & (value >> 32));}\n case 4 : { state.dest[destOffset++] = (byte) (255 & (value >> 24));}\n case 3 : { state.dest[destOffset++] = (byte) (255 & (value >> 16));}\n case 2 : { state.dest[destOffset++] = (byte) (255 & (value >> 8));}\n case 1 : { state.dest[destOffset++] = (byte) (255 & value );}\n default : { } //don't write anything - no length bytes to write, or invalid lengthLength (> 8)\n }\n blackhole.consume(state.dest);\n return state.dest;\n }\n\n @Benchmark\n @BenchmarkMode(Mode.Throughput)\n public Object forPerf1(BenchmarkState state, Blackhole blackhole) {\n long value = 123456789;\n int valueByteLength = 8;\n int destOffset = 0;\n\n for(int i=(valueByteLength-1)*8; i >= 0; i-=8){\n state.dest[destOffset++] = (byte) (255 & (value >> i));\n }\n blackhole.consume(state.dest);\n return state.dest;\n }\n\n @Benchmark\n @BenchmarkMode(Mode.Throughput)\n public Object forPerf2(BenchmarkState state, Blackhole blackhole) {\n long value = 123456789;\n int valueByteLength = 8;\n int destOffset = 0;\n\n for(int i=valueByteLength-1; i >= 0; i--){\n state.dest[destOffset++] = (byte) (255 & (value >> (i<<3)));\n }\n blackhole.consume(state.dest);\n return state.dest;\n }\n}","type":"blockquote","key":"4iq7q"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"#code #java #performance ","type":"unstyled","key":"37ns2"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"","type":"unstyled","key":"90dln"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"","type":"marker","key":"UCvm2FFrDSqXEJJy2eZw"}],"entityMap":{"0":{"data":{"href":"http://tutorials.jenkov.com/","url":"http://tutorials.jenkov.com/"},"mutability":"MUTABLE","type":"LINK"}}},"mentions":[]}