You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@flink.apache.org by za...@apache.org on 2024/10/10 09:25:16 UTC

(flink-benchmarks) 02/02: [FLINK-36322] Fix compile based on 2.0-preview

This is an automated email from the ASF dual-hosted git repository.

zakelly pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/flink-benchmarks.git

commit 61de85ea67e43c1778fc9de4599f5eb359e59425
Author: Zakelly <za...@gmail.com>
AuthorDate: Wed Oct 9 18:30:29 2024 +0800

    [FLINK-36322] Fix compile based on 2.0-preview
---
 .../benchmark/AsyncWaitOperatorBenchmark.java      |  2 +-
 .../apache/flink/benchmark/BackpressureUtils.java  |  2 +-
 .../benchmark/BlockingPartitionBenchmark.java      | 66 +++-------------------
 .../BlockingPartitionRemoteChannelBenchmark.java   | 31 +---------
 .../benchmark/CheckpointEnvironmentContext.java    | 14 ++---
 .../org/apache/flink/benchmark/CollectSink.java    |  2 +-
 .../ContinuousFileReaderOperatorBenchmark.java     |  6 +-
 .../flink/benchmark/FlinkEnvironmentContext.java   | 20 +++----
 .../org/apache/flink/benchmark/InputBenchmark.java |  2 +-
 .../apache/flink/benchmark/KeyByBenchmarks.java    | 10 ++--
 .../benchmark/MemoryStateBackendBenchmark.java     |  2 +-
 .../flink/benchmark/MultipleInputBenchmark.java    |  4 +-
 .../flink/benchmark/ProcessingTimerBenchmark.java  | 11 ++--
 .../RemoteChannelThroughputBenchmark.java          |  4 +-
 .../SerializationFrameworkMiniBenchmarks.java      | 16 +++---
 .../benchmark/SortingBoundedInputBenchmarks.java   |  2 +-
 .../flink/benchmark/StateBackendBenchmarkBase.java | 35 +++++++-----
 .../apache/flink/benchmark/StreamGraphUtils.java   |  2 +-
 .../apache/flink/benchmark/TwoInputBenchmark.java  |  2 +-
 .../apache/flink/benchmark/WindowBenchmarks.java   |  4 +-
 .../benchmark/full/PojoSerializationBenchmark.java |  4 +-
 .../full/SerializationFrameworkAllBenchmarks.java  | 33 ++++-------
 .../full/StringSerializationBenchmark.java         |  2 +-
 .../functions/BaseSourceWithKeyRange.java          |  3 +-
 .../benchmark/functions/IntegerLongSource.java     |  2 +-
 .../flink/benchmark/functions/LongSource.java      |  2 +-
 .../state/benchmark/RescalingBenchmarkBase.java    |  5 +-
 .../flink/state/benchmark/StateBenchmarkBase.java  |  2 +-
 .../org/apache/flink/config/ConfigUtilTest.java    |  2 +-
 29 files changed, 105 insertions(+), 187 deletions(-)

diff --git a/src/main/java/org/apache/flink/benchmark/AsyncWaitOperatorBenchmark.java b/src/main/java/org/apache/flink/benchmark/AsyncWaitOperatorBenchmark.java
index b61fd0c..20474c7 100644
--- a/src/main/java/org/apache/flink/benchmark/AsyncWaitOperatorBenchmark.java
+++ b/src/main/java/org/apache/flink/benchmark/AsyncWaitOperatorBenchmark.java
@@ -24,7 +24,7 @@ import org.apache.flink.streaming.api.datastream.DataStreamSource;
 import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
 import org.apache.flink.streaming.api.functions.async.ResultFuture;
 import org.apache.flink.streaming.api.functions.async.RichAsyncFunction;
-import org.apache.flink.streaming.api.functions.sink.DiscardingSink;
+import org.apache.flink.streaming.api.functions.sink.legacy.DiscardingSink;
 
 import org.openjdk.jmh.annotations.Benchmark;
 import org.openjdk.jmh.annotations.OperationsPerInvocation;
diff --git a/src/main/java/org/apache/flink/benchmark/BackpressureUtils.java b/src/main/java/org/apache/flink/benchmark/BackpressureUtils.java
index 7752ac5..fe2c947 100644
--- a/src/main/java/org/apache/flink/benchmark/BackpressureUtils.java
+++ b/src/main/java/org/apache/flink/benchmark/BackpressureUtils.java
@@ -73,7 +73,7 @@ public class BackpressureUtils {
             int port, Configuration clientConfiguration) throws Exception {
         final Configuration clientConfig = new Configuration();
         clientConfig.addAll(clientConfiguration);
-        clientConfig.setInteger(RestOptions.PORT, port);
+        clientConfig.set(RestOptions.PORT, port);
         return new RestClusterClient<>(clientConfig, StandaloneClusterId.getInstance());
     }
 
diff --git a/src/main/java/org/apache/flink/benchmark/BlockingPartitionBenchmark.java b/src/main/java/org/apache/flink/benchmark/BlockingPartitionBenchmark.java
index c447049..0159de1 100644
--- a/src/main/java/org/apache/flink/benchmark/BlockingPartitionBenchmark.java
+++ b/src/main/java/org/apache/flink/benchmark/BlockingPartitionBenchmark.java
@@ -60,22 +60,6 @@ public class BlockingPartitionBenchmark extends BenchmarkBase {
         executeBenchmark(context.env);
     }
 
-    @Benchmark
-    public void uncompressedMmapPartition(UncompressedMmapEnvironmentContext context)
-            throws Exception {
-        executeBenchmark(context.env);
-    }
-
-    @Benchmark
-    public void compressedSortPartition(CompressedSortEnvironmentContext context) throws Exception {
-        executeBenchmark(context.env);
-    }
-
-    @Benchmark
-    public void uncompressedSortPartition(UncompressedSortEnvironmentContext context) throws Exception {
-        executeBenchmark(context.env);
-    }
-
     private void executeBenchmark(StreamExecutionEnvironment env) throws Exception {
         StreamGraph streamGraph =
                 StreamGraphUtils.buildGraphForBatchJob(env, RECORDS_PER_INVOCATION);
@@ -102,23 +86,15 @@ public class BlockingPartitionBenchmark extends BenchmarkBase {
         }
 
         protected Configuration createConfiguration(
-                boolean compressionEnabled, String subpartitionType, boolean isSortShuffle) {
+                boolean compressionEnabled) {
             Configuration configuration = super.createConfiguration();
 
-            if (isSortShuffle) {
-                configuration.setInteger(
-                        NettyShuffleEnvironmentOptions.NETWORK_SORT_SHUFFLE_MIN_PARALLELISM, 1);
-            } else {
-                configuration.setInteger(
-                        NettyShuffleEnvironmentOptions.NETWORK_SORT_SHUFFLE_MIN_PARALLELISM,
-                        Integer.MAX_VALUE);
-            }
-            configuration.setBoolean(
-                    NettyShuffleEnvironmentOptions.BATCH_SHUFFLE_COMPRESSION_ENABLED,
-                    compressionEnabled);
-            configuration.setString(
-                    NettyShuffleEnvironmentOptions.NETWORK_BLOCKING_SHUFFLE_TYPE, subpartitionType);
-            configuration.setString(
+            configuration.set(
+                    NettyShuffleEnvironmentOptions.SHUFFLE_COMPRESSION_CODEC,
+                    compressionEnabled ?
+                            NettyShuffleEnvironmentOptions.CompressionCodec.LZ4
+                            : NettyShuffleEnvironmentOptions.CompressionCodec.NONE);
+            configuration.set(
                     CoreOptions.TMP_DIRS,
                     FileUtils.getCurrentWorkingDirectory().toAbsolutePath().toString());
             return configuration;
@@ -129,7 +105,7 @@ public class BlockingPartitionBenchmark extends BenchmarkBase {
             extends BlockingPartitionEnvironmentContext {
         @Override
         protected Configuration createConfiguration() {
-            return createConfiguration(false, "file", false);
+            return createConfiguration(false);
         }
     }
 
@@ -137,31 +113,7 @@ public class BlockingPartitionBenchmark extends BenchmarkBase {
             extends BlockingPartitionEnvironmentContext {
         @Override
         protected Configuration createConfiguration() {
-            return createConfiguration(true, "file", false);
-        }
-    }
-
-    public static class UncompressedMmapEnvironmentContext
-            extends BlockingPartitionEnvironmentContext {
-        @Override
-        protected Configuration createConfiguration() {
-            return createConfiguration(false, "mmap", false);
-        }
-    }
-
-    public static class CompressedSortEnvironmentContext
-            extends BlockingPartitionEnvironmentContext {
-        @Override
-        protected Configuration createConfiguration() {
-            return createConfiguration(true, "file", true);
-        }
-    }
-
-    public static class UncompressedSortEnvironmentContext
-            extends BlockingPartitionEnvironmentContext {
-        @Override
-        protected Configuration createConfiguration() {
-            return createConfiguration(false, "file", true);
+            return createConfiguration(true);
         }
     }
 }
diff --git a/src/main/java/org/apache/flink/benchmark/BlockingPartitionRemoteChannelBenchmark.java b/src/main/java/org/apache/flink/benchmark/BlockingPartitionRemoteChannelBenchmark.java
index ee69eb7..da411bb 100644
--- a/src/main/java/org/apache/flink/benchmark/BlockingPartitionRemoteChannelBenchmark.java
+++ b/src/main/java/org/apache/flink/benchmark/BlockingPartitionRemoteChannelBenchmark.java
@@ -48,14 +48,6 @@ public class BlockingPartitionRemoteChannelBenchmark extends RemoteBenchmarkBase
         new Runner(options).run();
     }
 
-    @Benchmark
-    public void remoteFilePartition(RemoteFileEnvironmentContext context) throws Exception {
-        StreamGraph streamGraph =
-                StreamGraphUtils.buildGraphForBatchJob(context.env, RECORDS_PER_INVOCATION);
-        context.miniCluster.executeJobBlocking(
-                StreamingJobGraphGenerator.createJobGraph(streamGraph));
-    }
-
     @Benchmark
     public void remoteSortPartition(RemoteSortEnvironmentContext context) throws Exception {
         StreamGraph streamGraph =
@@ -75,20 +67,10 @@ public class BlockingPartitionRemoteChannelBenchmark extends RemoteBenchmarkBase
             env.setBufferTimeout(-1);
         }
 
-        protected Configuration createConfiguration(boolean isSortShuffle) {
+        protected Configuration createConfiguration() {
             Configuration configuration = super.createConfiguration();
 
-            if (isSortShuffle) {
-                configuration.setInteger(
-                        NettyShuffleEnvironmentOptions.NETWORK_SORT_SHUFFLE_MIN_PARALLELISM, 1);
-            } else {
-                configuration.setInteger(
-                        NettyShuffleEnvironmentOptions.NETWORK_SORT_SHUFFLE_MIN_PARALLELISM,
-                        Integer.MAX_VALUE);
-            }
-            configuration.setString(
-                    NettyShuffleEnvironmentOptions.NETWORK_BLOCKING_SHUFFLE_TYPE, "file");
-            configuration.setString(
+            configuration.set(
                     CoreOptions.TMP_DIRS,
                     FileUtils.getCurrentWorkingDirectory().toAbsolutePath().toString());
             return configuration;
@@ -100,17 +82,10 @@ public class BlockingPartitionRemoteChannelBenchmark extends RemoteBenchmarkBase
         }
     }
 
-    public static class RemoteFileEnvironmentContext extends BlockingPartitionEnvironmentContext {
-        @Override
-        protected Configuration createConfiguration() {
-            return createConfiguration(false);
-        }
-    }
-
     public static class RemoteSortEnvironmentContext extends BlockingPartitionEnvironmentContext {
         @Override
         protected Configuration createConfiguration() {
-            return createConfiguration(true);
+            return super.createConfiguration();
         }
     }
 }
diff --git a/src/main/java/org/apache/flink/benchmark/CheckpointEnvironmentContext.java b/src/main/java/org/apache/flink/benchmark/CheckpointEnvironmentContext.java
index 374994f..0295cdf 100644
--- a/src/main/java/org/apache/flink/benchmark/CheckpointEnvironmentContext.java
+++ b/src/main/java/org/apache/flink/benchmark/CheckpointEnvironmentContext.java
@@ -19,14 +19,14 @@
 package org.apache.flink.benchmark;
 
 import org.apache.flink.api.common.JobID;
+import org.apache.flink.configuration.CheckpointingOptions;
 import org.apache.flink.configuration.Configuration;
 import org.apache.flink.configuration.MemorySize;
 import org.apache.flink.configuration.TaskManagerOptions;
 import org.apache.flink.core.execution.JobClient;
 import org.apache.flink.runtime.jobgraph.JobVertexID;
 import org.apache.flink.runtime.testutils.CommonTestUtils;
-import org.apache.flink.streaming.api.environment.ExecutionCheckpointingOptions;
-import org.apache.flink.streaming.api.functions.sink.SinkFunction;
+import org.apache.flink.streaming.api.functions.sink.legacy.SinkFunction;
 import org.apache.flink.streaming.api.graph.StreamGraph;
 
 import java.time.Duration;
@@ -93,31 +93,31 @@ public abstract class CheckpointEnvironmentContext extends FlinkEnvironmentConte
     public enum CheckpointMode {
         UNALIGNED(
                 config -> {
-                    config.set(ExecutionCheckpointingOptions.ENABLE_UNALIGNED, true);
+                    config.set(CheckpointingOptions.ENABLE_UNALIGNED, true);
                     config.set(
                             TaskManagerOptions.MEMORY_SEGMENT_SIZE,
                             CheckpointEnvironmentContext.START_MEMORY_SEGMENT_SIZE);
                     config.set(
-                            ExecutionCheckpointingOptions.ALIGNED_CHECKPOINT_TIMEOUT,
+                            CheckpointingOptions.ALIGNED_CHECKPOINT_TIMEOUT,
                             Duration.ofMillis(0));
                     config.set(TaskManagerOptions.BUFFER_DEBLOAT_ENABLED, false);
                     return config;
                 }),
         UNALIGNED_1(
                 config -> {
-                    config.set(ExecutionCheckpointingOptions.ENABLE_UNALIGNED, true);
+                    config.set(CheckpointingOptions.ENABLE_UNALIGNED, true);
                     config.set(
                             TaskManagerOptions.MEMORY_SEGMENT_SIZE,
                             CheckpointEnvironmentContext.START_MEMORY_SEGMENT_SIZE);
                     config.set(
-                            ExecutionCheckpointingOptions.ALIGNED_CHECKPOINT_TIMEOUT,
+                            CheckpointingOptions.ALIGNED_CHECKPOINT_TIMEOUT,
                             Duration.ofMillis(1));
                     config.set(TaskManagerOptions.BUFFER_DEBLOAT_ENABLED, false);
                     return config;
                 }),
         ALIGNED(
                 config -> {
-                    config.set(ExecutionCheckpointingOptions.ENABLE_UNALIGNED, false);
+                    config.set(CheckpointingOptions.ENABLE_UNALIGNED, false);
                     config.set(
                             TaskManagerOptions.MEMORY_SEGMENT_SIZE,
                             CheckpointEnvironmentContext.START_MEMORY_SEGMENT_SIZE);
diff --git a/src/main/java/org/apache/flink/benchmark/CollectSink.java b/src/main/java/org/apache/flink/benchmark/CollectSink.java
index ba1b82c..1282e2c 100644
--- a/src/main/java/org/apache/flink/benchmark/CollectSink.java
+++ b/src/main/java/org/apache/flink/benchmark/CollectSink.java
@@ -18,7 +18,7 @@
 
 package org.apache.flink.benchmark;
 
-import org.apache.flink.streaming.api.functions.sink.SinkFunction;
+import org.apache.flink.streaming.api.functions.sink.legacy.SinkFunction;
 
 import java.util.ArrayList;
 import java.util.List;
diff --git a/src/main/java/org/apache/flink/benchmark/ContinuousFileReaderOperatorBenchmark.java b/src/main/java/org/apache/flink/benchmark/ContinuousFileReaderOperatorBenchmark.java
index a829823..be13691 100644
--- a/src/main/java/org/apache/flink/benchmark/ContinuousFileReaderOperatorBenchmark.java
+++ b/src/main/java/org/apache/flink/benchmark/ContinuousFileReaderOperatorBenchmark.java
@@ -18,19 +18,18 @@
 package org.apache.flink.benchmark;
 
 import org.apache.flink.api.common.io.FileInputFormat;
-import org.apache.flink.api.common.restartstrategy.RestartStrategies;
 import org.apache.flink.api.common.typeinfo.TypeInformation;
 import org.apache.flink.configuration.Configuration;
 import org.apache.flink.core.fs.FileInputSplit;
 import org.apache.flink.core.fs.Path;
 import org.apache.flink.core.testutils.OneShotLatch;
 import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
-import org.apache.flink.streaming.api.functions.sink.SinkFunction;
+import org.apache.flink.streaming.api.functions.sink.legacy.SinkFunction;
 import org.apache.flink.streaming.api.functions.source.ContinuousFileReaderOperatorFactory;
-import org.apache.flink.streaming.api.functions.source.SourceFunction;
 import org.apache.flink.streaming.api.functions.source.TimestampedFileInputSplit;
 
 import joptsimple.internal.Strings;
+import org.apache.flink.streaming.api.functions.source.legacy.SourceFunction;
 import org.openjdk.jmh.annotations.Benchmark;
 import org.openjdk.jmh.annotations.OperationsPerInvocation;
 import org.openjdk.jmh.runner.Runner;
@@ -76,7 +75,6 @@ public class ContinuousFileReaderOperatorBenchmark extends BenchmarkBase {
     public void readFileSplit(FlinkEnvironmentContext context) throws Exception {
         TARGET_COUNT_REACHED_LATCH.reset();
         StreamExecutionEnvironment env = context.env;
-        env.setRestartStrategy(new RestartStrategies.NoRestartStrategyConfiguration());
         env.enableCheckpointing(100)
                 .setParallelism(1)
                 .addSource(new MockSourceFunction())
diff --git a/src/main/java/org/apache/flink/benchmark/FlinkEnvironmentContext.java b/src/main/java/org/apache/flink/benchmark/FlinkEnvironmentContext.java
index 1b09133..b51de81 100644
--- a/src/main/java/org/apache/flink/benchmark/FlinkEnvironmentContext.java
+++ b/src/main/java/org/apache/flink/benchmark/FlinkEnvironmentContext.java
@@ -18,15 +18,14 @@
 
 package org.apache.flink.benchmark;
 
-import org.apache.flink.api.common.restartstrategy.RestartStrategies;
+import org.apache.flink.configuration.CheckpointingOptions;
 import org.apache.flink.configuration.Configuration;
 import org.apache.flink.configuration.DeploymentOptions;
-import org.apache.flink.configuration.NettyShuffleEnvironmentOptions;
 import org.apache.flink.configuration.RestOptions;
+import org.apache.flink.configuration.RestartStrategyOptions;
+import org.apache.flink.configuration.StateBackendOptions;
 import org.apache.flink.runtime.minicluster.MiniCluster;
 import org.apache.flink.runtime.minicluster.MiniClusterConfiguration;
-import org.apache.flink.runtime.state.memory.MemoryStateBackend;
-import org.apache.flink.streaming.api.environment.ExecutionCheckpointingOptions;
 import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
 import org.apache.flink.test.util.MiniClusterPipelineExecutorServiceLoader;
 
@@ -54,6 +53,8 @@ public class FlinkEnvironmentContext {
             throw new RuntimeException("setUp was called multiple times!");
         }
         final Configuration clusterConfig = createConfiguration();
+        clusterConfig.set(RestartStrategyOptions.RESTART_STRATEGY, "none");
+        clusterConfig.set(StateBackendOptions.STATE_BACKEND, "hashmap");
         miniCluster =
                 new MiniCluster(
                         new MiniClusterConfiguration.Builder()
@@ -78,8 +79,6 @@ public class FlinkEnvironmentContext {
         if (objectReuse) {
             env.getConfig().enableObjectReuse();
         }
-        env.setRestartStrategy(RestartStrategies.noRestart());
-        env.setStateBackend(new MemoryStateBackend());
     }
 
     @TearDown
@@ -102,14 +101,15 @@ public class FlinkEnvironmentContext {
 
     protected Configuration createConfiguration() {
         final Configuration configuration = new Configuration();
-        configuration.setString(RestOptions.BIND_PORT, "0");
-        configuration.setInteger(
-                NettyShuffleEnvironmentOptions.NETWORK_NUM_BUFFERS, NUM_NETWORK_BUFFERS);
+        configuration.set(RestOptions.BIND_PORT, "0");
+        // no equivalent config available.
+        //configuration.setInteger(
+        //        NettyShuffleEnvironmentOptions.NETWORK_NUM_BUFFERS, NUM_NETWORK_BUFFERS);
         configuration.set(DeploymentOptions.TARGET, MiniClusterPipelineExecutorServiceLoader.NAME);
         configuration.set(DeploymentOptions.ATTACHED, true);
         // It doesn't make sense to wait for the final checkpoint in benchmarks since it only prolongs
         // the test but doesn't give any advantages.
-        configuration.set(ExecutionCheckpointingOptions.ENABLE_CHECKPOINTS_AFTER_TASKS_FINISH, false);
+        configuration.set(CheckpointingOptions.ENABLE_CHECKPOINTS_AFTER_TASKS_FINISH, false);
         // TODO: remove this line after FLINK-28243 will be done
         configuration.set(REQUIREMENTS_CHECK_DELAY, Duration.ZERO);
         return configuration;
diff --git a/src/main/java/org/apache/flink/benchmark/InputBenchmark.java b/src/main/java/org/apache/flink/benchmark/InputBenchmark.java
index 08b3fcf..62e5d4d 100644
--- a/src/main/java/org/apache/flink/benchmark/InputBenchmark.java
+++ b/src/main/java/org/apache/flink/benchmark/InputBenchmark.java
@@ -22,7 +22,7 @@ import org.apache.flink.benchmark.functions.LongSourceType;
 import org.apache.flink.benchmark.functions.MultiplyByTwo;
 import org.apache.flink.streaming.api.datastream.DataStreamSource;
 import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
-import org.apache.flink.streaming.api.functions.sink.DiscardingSink;
+import org.apache.flink.streaming.api.functions.sink.legacy.DiscardingSink;
 
 import org.openjdk.jmh.annotations.Benchmark;
 import org.openjdk.jmh.annotations.OperationsPerInvocation;
diff --git a/src/main/java/org/apache/flink/benchmark/KeyByBenchmarks.java b/src/main/java/org/apache/flink/benchmark/KeyByBenchmarks.java
index 3fdc289..c4cb907 100644
--- a/src/main/java/org/apache/flink/benchmark/KeyByBenchmarks.java
+++ b/src/main/java/org/apache/flink/benchmark/KeyByBenchmarks.java
@@ -20,9 +20,11 @@ package org.apache.flink.benchmark;
 
 import org.apache.flink.api.java.tuple.Tuple2;
 import org.apache.flink.benchmark.functions.BaseSourceWithKeyRange;
+import org.apache.flink.streaming.api.datastream.DataStreamSource;
 import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
-import org.apache.flink.streaming.api.functions.sink.DiscardingSink;
+import org.apache.flink.streaming.api.functions.sink.legacy.DiscardingSink;
 
+import org.apache.flink.streaming.util.keys.KeySelectorUtil;
 import org.openjdk.jmh.annotations.Benchmark;
 import org.openjdk.jmh.annotations.OperationsPerInvocation;
 import org.openjdk.jmh.runner.Runner;
@@ -54,7 +56,7 @@ public class KeyByBenchmarks extends BenchmarkBase {
         env.setParallelism(4);
 
         env.addSource(new IncreasingTupleSource(TUPLE_RECORDS_PER_INVOCATION, 10))
-                .keyBy(0)
+                .keyBy(e -> e.f0)
                 .addSink(new DiscardingSink<>());
 
         env.execute();
@@ -66,8 +68,8 @@ public class KeyByBenchmarks extends BenchmarkBase {
         StreamExecutionEnvironment env = context.env;
         env.setParallelism(4);
 
-        env.addSource(new IncreasingArraySource(ARRAY_RECORDS_PER_INVOCATION, 10))
-                .keyBy(0)
+        DataStreamSource<int[]> source = env.addSource(new IncreasingArraySource(ARRAY_RECORDS_PER_INVOCATION, 10));
+        source.keyBy(KeySelectorUtil.getSelectorForArray(new int[]{0}, source.getType()))
                 .addSink(new DiscardingSink<>());
 
         env.execute();
diff --git a/src/main/java/org/apache/flink/benchmark/MemoryStateBackendBenchmark.java b/src/main/java/org/apache/flink/benchmark/MemoryStateBackendBenchmark.java
index 706aad3..35b01d6 100644
--- a/src/main/java/org/apache/flink/benchmark/MemoryStateBackendBenchmark.java
+++ b/src/main/java/org/apache/flink/benchmark/MemoryStateBackendBenchmark.java
@@ -58,7 +58,7 @@ public class MemoryStateBackendBenchmark extends StateBackendBenchmarkBase {
 
     @State(Thread)
     public static class MemoryStateBackendContext extends StateBackendContext {
-        @Param({"MEMORY", "FS", "FS_ASYNC"})
+        @Param({"MEMORY", "FS"})
         public StateBackend stateBackend = StateBackend.MEMORY;
 
         @Override
diff --git a/src/main/java/org/apache/flink/benchmark/MultipleInputBenchmark.java b/src/main/java/org/apache/flink/benchmark/MultipleInputBenchmark.java
index 1ec8920..72ad6c8 100644
--- a/src/main/java/org/apache/flink/benchmark/MultipleInputBenchmark.java
+++ b/src/main/java/org/apache/flink/benchmark/MultipleInputBenchmark.java
@@ -36,8 +36,8 @@ import org.apache.flink.streaming.api.datastream.DataStream;
 import org.apache.flink.streaming.api.datastream.DataStreamSource;
 import org.apache.flink.streaming.api.datastream.MultipleConnectedStreams;
 import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
-import org.apache.flink.streaming.api.functions.sink.DiscardingSink;
-import org.apache.flink.streaming.api.functions.sink.SinkFunction;
+import org.apache.flink.streaming.api.functions.sink.legacy.DiscardingSink;
+import org.apache.flink.streaming.api.functions.sink.legacy.SinkFunction;
 import org.apache.flink.streaming.api.operators.ChainingStrategy;
 import org.apache.flink.streaming.api.transformations.MultipleInputTransformation;
 
diff --git a/src/main/java/org/apache/flink/benchmark/ProcessingTimerBenchmark.java b/src/main/java/org/apache/flink/benchmark/ProcessingTimerBenchmark.java
index 721f31f..93a433c 100644
--- a/src/main/java/org/apache/flink/benchmark/ProcessingTimerBenchmark.java
+++ b/src/main/java/org/apache/flink/benchmark/ProcessingTimerBenchmark.java
@@ -17,14 +17,13 @@
 
 package org.apache.flink.benchmark;
 
-import org.apache.flink.configuration.Configuration;
+import org.apache.flink.api.common.functions.OpenContext;
 import org.apache.flink.core.testutils.OneShotLatch;
 import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
 import org.apache.flink.streaming.api.functions.KeyedProcessFunction;
-import org.apache.flink.streaming.api.functions.sink.DiscardingSink;
-import org.apache.flink.streaming.api.functions.source.RichParallelSourceFunction;
+import org.apache.flink.streaming.api.functions.sink.legacy.DiscardingSink;
+import org.apache.flink.streaming.api.functions.source.legacy.RichParallelSourceFunction;
 import org.apache.flink.util.Collector;
-
 import org.openjdk.jmh.annotations.Benchmark;
 import org.openjdk.jmh.annotations.OperationsPerInvocation;
 import org.openjdk.jmh.runner.Runner;
@@ -75,7 +74,7 @@ public class ProcessingTimerBenchmark extends BenchmarkBase {
         public SingleRecordSource() {}
 
         @Override
-        public void open(Configuration parameters) throws Exception {
+        public void open(OpenContext openContext) throws Exception {
             this.random = new Random();
         }
 
@@ -103,7 +102,7 @@ public class ProcessingTimerBenchmark extends BenchmarkBase {
         }
 
         @Override
-        public void open(Configuration parameters) throws Exception {
+        public void open(OpenContext context) throws Exception {
             this.firedTimesCount = 0;
         }
 
diff --git a/src/main/java/org/apache/flink/benchmark/RemoteChannelThroughputBenchmark.java b/src/main/java/org/apache/flink/benchmark/RemoteChannelThroughputBenchmark.java
index 4895be8..6b0d79d 100644
--- a/src/main/java/org/apache/flink/benchmark/RemoteChannelThroughputBenchmark.java
+++ b/src/main/java/org/apache/flink/benchmark/RemoteChannelThroughputBenchmark.java
@@ -24,7 +24,7 @@ import org.apache.flink.configuration.Configuration;
 import org.apache.flink.configuration.TaskManagerOptions;
 import org.apache.flink.streaming.api.datastream.DataStreamSource;
 import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
-import org.apache.flink.streaming.api.functions.sink.DiscardingSink;
+import org.apache.flink.streaming.api.functions.sink.legacy.DiscardingSink;
 import org.apache.flink.streaming.api.graph.StreamingJobGraphGenerator;
 
 import org.openjdk.jmh.annotations.Benchmark;
@@ -86,7 +86,7 @@ public class RemoteChannelThroughputBenchmark extends RemoteBenchmarkBase {
         protected Configuration createConfiguration() {
             Configuration configuration = super.createConfiguration();
             if (mode.equals(DEBLOAT)) {
-                configuration.setBoolean(TaskManagerOptions.BUFFER_DEBLOAT_ENABLED, true);
+                configuration.set(TaskManagerOptions.BUFFER_DEBLOAT_ENABLED, true);
             }
             return configuration;
         }
diff --git a/src/main/java/org/apache/flink/benchmark/SerializationFrameworkMiniBenchmarks.java b/src/main/java/org/apache/flink/benchmark/SerializationFrameworkMiniBenchmarks.java
index 37ba535..8d23b6e 100644
--- a/src/main/java/org/apache/flink/benchmark/SerializationFrameworkMiniBenchmarks.java
+++ b/src/main/java/org/apache/flink/benchmark/SerializationFrameworkMiniBenchmarks.java
@@ -27,7 +27,7 @@ import org.apache.flink.api.java.typeutils.ResultTypeQueryable;
 import org.apache.flink.benchmark.full.StringSerializationBenchmark;
 import org.apache.flink.benchmark.functions.BaseSourceWithKeyRange;
 import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
-import org.apache.flink.streaming.api.functions.sink.DiscardingSink;
+import org.apache.flink.streaming.api.functions.sink.legacy.DiscardingSink;
 import org.apache.flink.types.Row;
 
 import org.openjdk.jmh.annotations.Benchmark;
@@ -67,8 +67,8 @@ public class SerializationFrameworkMiniBenchmarks extends BenchmarkBase {
         StreamExecutionEnvironment env = context.env;
         env.setParallelism(4);
         ExecutionConfig executionConfig = env.getConfig();
-        executionConfig.registerPojoType(MyPojo.class);
-        executionConfig.registerPojoType(MyOperation.class);
+        executionConfig.getSerializerConfig().registerPojoType(MyPojo.class);
+        executionConfig.getSerializerConfig().registerPojoType(MyOperation.class);
 
         env.addSource(new PojoSource(RECORDS_PER_INVOCATION, 10))
                 .rebalance()
@@ -83,8 +83,8 @@ public class SerializationFrameworkMiniBenchmarks extends BenchmarkBase {
         StreamExecutionEnvironment env = context.env;
         env.setParallelism(1);
         ExecutionConfig executionConfig = env.getConfig();
-        executionConfig.registerPojoType(MyPojo.class);
-        executionConfig.registerPojoType(MyOperation.class);
+        executionConfig.getSerializerConfig().registerPojoType(MyPojo.class);
+        executionConfig.getSerializerConfig().registerPojoType(MyOperation.class);
 
         env.addSource(new LongStringSource(RECORDS_PER_INVOCATION, 12))
                 .rebalance()
@@ -112,9 +112,9 @@ public class SerializationFrameworkMiniBenchmarks extends BenchmarkBase {
         StreamExecutionEnvironment env = context.env;
         env.setParallelism(4);
         ExecutionConfig executionConfig = env.getConfig();
-        executionConfig.enableForceKryo();
-        executionConfig.registerKryoType(MyPojo.class);
-        executionConfig.registerKryoType(MyOperation.class);
+        executionConfig.getSerializerConfig().setForceKryo(true);
+        executionConfig.getSerializerConfig().registerKryoType(MyPojo.class);
+        executionConfig.getSerializerConfig().registerKryoType(MyOperation.class);
 
         env.addSource(new PojoSource(RECORDS_PER_INVOCATION, 10))
                 .rebalance()
diff --git a/src/main/java/org/apache/flink/benchmark/SortingBoundedInputBenchmarks.java b/src/main/java/org/apache/flink/benchmark/SortingBoundedInputBenchmarks.java
index 009c423..5f98941 100644
--- a/src/main/java/org/apache/flink/benchmark/SortingBoundedInputBenchmarks.java
+++ b/src/main/java/org/apache/flink/benchmark/SortingBoundedInputBenchmarks.java
@@ -28,7 +28,7 @@ import org.apache.flink.streaming.api.datastream.DataStreamSource;
 import org.apache.flink.streaming.api.datastream.KeyedStream;
 import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
 import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
-import org.apache.flink.streaming.api.functions.sink.DiscardingSink;
+import org.apache.flink.streaming.api.functions.sink.legacy.DiscardingSink;
 import org.apache.flink.streaming.api.operators.AbstractStreamOperator;
 import org.apache.flink.streaming.api.operators.AbstractStreamOperatorV2;
 import org.apache.flink.streaming.api.operators.BoundedMultiInput;
diff --git a/src/main/java/org/apache/flink/benchmark/StateBackendBenchmarkBase.java b/src/main/java/org/apache/flink/benchmark/StateBackendBenchmarkBase.java
index f3c81d1..00d665e 100644
--- a/src/main/java/org/apache/flink/benchmark/StateBackendBenchmarkBase.java
+++ b/src/main/java/org/apache/flink/benchmark/StateBackendBenchmarkBase.java
@@ -19,11 +19,13 @@
 package org.apache.flink.benchmark;
 
 import org.apache.flink.benchmark.functions.IntegerLongSource;
-import org.apache.flink.contrib.streaming.state.RocksDBStateBackend;
+import org.apache.flink.configuration.CheckpointingOptions;
+import org.apache.flink.configuration.Configuration;
+import org.apache.flink.configuration.ReadableConfig;
+import org.apache.flink.configuration.StateBackendOptions;
+import org.apache.flink.contrib.streaming.state.EmbeddedRocksDBStateBackend;
 import org.apache.flink.runtime.state.AbstractStateBackend;
-import org.apache.flink.runtime.state.filesystem.FsStateBackend;
-import org.apache.flink.runtime.state.memory.MemoryStateBackend;
-import org.apache.flink.streaming.api.TimeCharacteristic;
+import org.apache.flink.runtime.state.hashmap.HashMapStateBackend;
 import org.apache.flink.streaming.api.datastream.DataStreamSource;
 import org.apache.flink.util.FileUtils;
 
@@ -63,32 +65,35 @@ public class StateBackendBenchmarkBase extends BenchmarkBase {
                 e.printStackTrace();
             }
 
-            final AbstractStateBackend backend;
+
+            Configuration configuration = Configuration.fromMap(env.getConfiguration().toMap());
             String checkpointDataUri = "file://" + checkpointDir.getAbsolutePath();
             switch (stateBackend) {
                 case MEMORY:
-                    backend = new MemoryStateBackend();
+                    configuration.set(StateBackendOptions.STATE_BACKEND, "hashmap");
+                    configuration.set(CheckpointingOptions.CHECKPOINT_STORAGE, "jobmanager");
                     break;
                 case FS:
-                    backend = new FsStateBackend(checkpointDataUri, false);
-                    break;
-                case FS_ASYNC:
-                    backend = new FsStateBackend(checkpointDataUri, true);
+                    configuration.set(StateBackendOptions.STATE_BACKEND, "hashmap");
+                    configuration.set(CheckpointingOptions.CHECKPOINT_STORAGE, "filesystem");
                     break;
                 case ROCKS:
-                    backend = new RocksDBStateBackend(checkpointDataUri, false);
+                    configuration.set(StateBackendOptions.STATE_BACKEND, "rocksdb");
+                    configuration.set(CheckpointingOptions.CHECKPOINT_STORAGE, "filesystem");
+                    configuration.set(CheckpointingOptions.INCREMENTAL_CHECKPOINTS, false);
                     break;
                 case ROCKS_INC:
-                    backend = new RocksDBStateBackend(checkpointDataUri, true);
+                    configuration.set(StateBackendOptions.STATE_BACKEND, "rocksdb");
+                    configuration.set(CheckpointingOptions.CHECKPOINT_STORAGE, "filesystem");
+                    configuration.set(CheckpointingOptions.INCREMENTAL_CHECKPOINTS, true);
                     break;
                 default:
                     throw new UnsupportedOperationException(
                             "Unknown state backend: " + stateBackend);
             }
 
-            env.setStateBackend(backend);
-
-            env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime);
+            // default character
+            //env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime);
             source = env.addSource(new IntegerLongSource(numberOfElements, recordsPerInvocation));
         }
 
diff --git a/src/main/java/org/apache/flink/benchmark/StreamGraphUtils.java b/src/main/java/org/apache/flink/benchmark/StreamGraphUtils.java
index 2cb8e3e..707804f 100644
--- a/src/main/java/org/apache/flink/benchmark/StreamGraphUtils.java
+++ b/src/main/java/org/apache/flink/benchmark/StreamGraphUtils.java
@@ -24,7 +24,7 @@ import org.apache.flink.configuration.PipelineOptions;
 import org.apache.flink.runtime.jobgraph.JobType;
 import org.apache.flink.streaming.api.datastream.DataStreamSource;
 import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
-import org.apache.flink.streaming.api.functions.sink.DiscardingSink;
+import org.apache.flink.streaming.api.functions.sink.legacy.DiscardingSink;
 import org.apache.flink.streaming.api.graph.GlobalStreamExchangeMode;
 import org.apache.flink.streaming.api.graph.StreamGraph;
 
diff --git a/src/main/java/org/apache/flink/benchmark/TwoInputBenchmark.java b/src/main/java/org/apache/flink/benchmark/TwoInputBenchmark.java
index b0f1144..454191a 100644
--- a/src/main/java/org/apache/flink/benchmark/TwoInputBenchmark.java
+++ b/src/main/java/org/apache/flink/benchmark/TwoInputBenchmark.java
@@ -24,7 +24,7 @@ import org.apache.flink.benchmark.functions.QueuingLongSource;
 import org.apache.flink.benchmark.operators.MultiplyByTwoCoStreamMap;
 import org.apache.flink.streaming.api.datastream.DataStreamSource;
 import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
-import org.apache.flink.streaming.api.functions.sink.DiscardingSink;
+import org.apache.flink.streaming.api.functions.sink.legacy.DiscardingSink;
 
 import org.openjdk.jmh.annotations.Benchmark;
 import org.openjdk.jmh.annotations.OperationsPerInvocation;
diff --git a/src/main/java/org/apache/flink/benchmark/WindowBenchmarks.java b/src/main/java/org/apache/flink/benchmark/WindowBenchmarks.java
index 5db870b..6aff71d 100644
--- a/src/main/java/org/apache/flink/benchmark/WindowBenchmarks.java
+++ b/src/main/java/org/apache/flink/benchmark/WindowBenchmarks.java
@@ -20,7 +20,6 @@ package org.apache.flink.benchmark;
 
 import org.apache.flink.benchmark.functions.IntLongApplications;
 import org.apache.flink.benchmark.functions.IntegerLongSource;
-import org.apache.flink.streaming.api.TimeCharacteristic;
 import org.apache.flink.streaming.api.datastream.DataStreamSource;
 import org.apache.flink.streaming.api.windowing.assigners.EventTimeSessionWindows;
 import org.apache.flink.streaming.api.windowing.assigners.GlobalWindows;
@@ -89,7 +88,8 @@ public class WindowBenchmarks extends BenchmarkBase {
         public void setUp() throws Exception {
             super.setUp();
 
-            env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime);
+            // event time is default
+            // env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime);
             source = env.addSource(new IntegerLongSource(numberOfElements, RECORDS_PER_INVOCATION));
         }
     }
diff --git a/src/main/java/org/apache/flink/benchmark/full/PojoSerializationBenchmark.java b/src/main/java/org/apache/flink/benchmark/full/PojoSerializationBenchmark.java
index 1c98e9f..f6a961b 100644
--- a/src/main/java/org/apache/flink/benchmark/full/PojoSerializationBenchmark.java
+++ b/src/main/java/org/apache/flink/benchmark/full/PojoSerializationBenchmark.java
@@ -59,9 +59,9 @@ public class PojoSerializationBenchmark extends BenchmarkBase {
     ExecutionConfig config = new ExecutionConfig();
     TypeSerializer<SerializationFrameworkMiniBenchmarks.MyPojo> pojoSerializer =
             TypeInformation.of(SerializationFrameworkMiniBenchmarks.MyPojo.class)
-                    .createSerializer(config);
+                    .createSerializer(config.getSerializerConfig());
     TypeSerializer<SerializationFrameworkMiniBenchmarks.MyPojo> kryoSerializer =
-            new KryoSerializer<>(SerializationFrameworkMiniBenchmarks.MyPojo.class, config);
+            new KryoSerializer<>(SerializationFrameworkMiniBenchmarks.MyPojo.class, config.getSerializerConfig());
     TypeSerializer<org.apache.flink.benchmark.avro.MyPojo> avroSerializer =
             new AvroSerializer<>(org.apache.flink.benchmark.avro.MyPojo.class);
 
diff --git a/src/main/java/org/apache/flink/benchmark/full/SerializationFrameworkAllBenchmarks.java b/src/main/java/org/apache/flink/benchmark/full/SerializationFrameworkAllBenchmarks.java
index 00d40c5..7053465 100644
--- a/src/main/java/org/apache/flink/benchmark/full/SerializationFrameworkAllBenchmarks.java
+++ b/src/main/java/org/apache/flink/benchmark/full/SerializationFrameworkAllBenchmarks.java
@@ -24,10 +24,9 @@ import org.apache.flink.api.java.typeutils.ResultTypeQueryable;
 import org.apache.flink.benchmark.FlinkEnvironmentContext;
 import org.apache.flink.benchmark.SerializationFrameworkMiniBenchmarks;
 import org.apache.flink.benchmark.functions.BaseSourceWithKeyRange;
-import org.apache.flink.benchmark.functions.ScalaADTSource;
 import org.apache.flink.formats.avro.typeutils.GenericRecordAvroTypeInfo;
 import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
-import org.apache.flink.streaming.api.functions.sink.DiscardingSink;
+import org.apache.flink.streaming.api.functions.sink.legacy.DiscardingSink;
 
 import com.twitter.chill.protobuf.ProtobufSerializer;
 import com.twitter.chill.thrift.TBaseSerializer;
@@ -84,7 +83,7 @@ public class SerializationFrameworkAllBenchmarks extends SerializationFrameworkM
             throws Exception {
         StreamExecutionEnvironment env = context.env;
         env.setParallelism(4);
-        env.getConfig().enableForceKryo();
+        env.getConfig().getSerializerConfig().setForceAvro(true);
 
         env.addSource(new PojoSource(RECORDS_PER_INVOCATION, 10))
                 .rebalance()
@@ -98,7 +97,7 @@ public class SerializationFrameworkAllBenchmarks extends SerializationFrameworkM
     public void serializerAvroReflect(FlinkEnvironmentContext context) throws Exception {
         StreamExecutionEnvironment env = context.env;
         env.setParallelism(4);
-        env.getConfig().enableForceAvro();
+        env.getConfig().getSerializerConfig().setForceAvro(true);
 
         env.addSource(new PojoSource(RECORDS_PER_INVOCATION, 10))
                 .rebalance()
@@ -121,29 +120,17 @@ public class SerializationFrameworkAllBenchmarks extends SerializationFrameworkM
         env.execute();
     }
 
-    @Benchmark
-    @OperationsPerInvocation(value = SerializationFrameworkMiniBenchmarks.RECORDS_PER_INVOCATION)
-    public void serializerScalaADT(FlinkEnvironmentContext context) throws Exception {
-        StreamExecutionEnvironment env = context.env;
-        env.setParallelism(4);
-
-        env.addSource(new ScalaADTSource(RECORDS_PER_INVOCATION), ScalaADTSource.adtTypeInfo())
-                .rebalance()
-                .addSink(new DiscardingSink<>());
-
-        env.execute();
-    }
-
     @Benchmark
     @OperationsPerInvocation(value = SerializationFrameworkMiniBenchmarks.RECORDS_PER_INVOCATION)
     public void serializerKryoThrift(FlinkEnvironmentContext context) throws Exception {
         StreamExecutionEnvironment env = context.env;
         env.setParallelism(4);
         ExecutionConfig executionConfig = env.getConfig();
-        executionConfig.enableForceKryo();
-        executionConfig.addDefaultKryoSerializer(
+
+        executionConfig.getSerializerConfig().setForceKryo(true);
+        executionConfig.getSerializerConfig().addDefaultKryoSerializer(
                 org.apache.flink.benchmark.thrift.MyPojo.class, TBaseSerializer.class);
-        executionConfig.addDefaultKryoSerializer(
+        executionConfig.getSerializerConfig().addDefaultKryoSerializer(
                 org.apache.flink.benchmark.thrift.MyOperation.class, TBaseSerializer.class);
 
         env.addSource(new ThriftPojoSource(RECORDS_PER_INVOCATION, 10))
@@ -159,11 +146,11 @@ public class SerializationFrameworkAllBenchmarks extends SerializationFrameworkM
         StreamExecutionEnvironment env = context.env;
         env.setParallelism(4);
         ExecutionConfig executionConfig = env.getConfig();
-        executionConfig.enableForceKryo();
-        executionConfig.registerTypeWithKryoSerializer(
+        executionConfig.getSerializerConfig().setForceKryo(true);
+        executionConfig.getSerializerConfig().registerTypeWithKryoSerializer(
                 org.apache.flink.benchmark.protobuf.MyPojoOuterClass.MyPojo.class,
                 ProtobufSerializer.class);
-        executionConfig.registerTypeWithKryoSerializer(
+        executionConfig.getSerializerConfig().registerTypeWithKryoSerializer(
                 org.apache.flink.benchmark.protobuf.MyPojoOuterClass.MyOperation.class,
                 ProtobufSerializer.class);
 
diff --git a/src/main/java/org/apache/flink/benchmark/full/StringSerializationBenchmark.java b/src/main/java/org/apache/flink/benchmark/full/StringSerializationBenchmark.java
index 57ded08..6cc032e 100644
--- a/src/main/java/org/apache/flink/benchmark/full/StringSerializationBenchmark.java
+++ b/src/main/java/org/apache/flink/benchmark/full/StringSerializationBenchmark.java
@@ -65,7 +65,7 @@ public class StringSerializationBenchmark extends BenchmarkBase {
     int length;
     String input;
     ExecutionConfig config = new ExecutionConfig();
-    TypeSerializer<String> serializer = TypeInformation.of(String.class).createSerializer(config);
+    TypeSerializer<String> serializer = TypeInformation.of(String.class).createSerializer(config.getSerializerConfig());
     ByteArrayInputStream serializedBuffer;
     DataInputView serializedStream;
 
diff --git a/src/main/java/org/apache/flink/benchmark/functions/BaseSourceWithKeyRange.java b/src/main/java/org/apache/flink/benchmark/functions/BaseSourceWithKeyRange.java
index 7629c84..e44b59b 100644
--- a/src/main/java/org/apache/flink/benchmark/functions/BaseSourceWithKeyRange.java
+++ b/src/main/java/org/apache/flink/benchmark/functions/BaseSourceWithKeyRange.java
@@ -18,8 +18,7 @@
 
 package org.apache.flink.benchmark.functions;
 
-import org.apache.flink.streaming.api.functions.source.ParallelSourceFunction;
-import org.apache.flink.streaming.api.functions.source.SourceFunction.SourceContext;
+import org.apache.flink.streaming.api.functions.source.legacy.ParallelSourceFunction;
 
 /** Abstract base class for sources with a defined number of events and a fixed key range. */
 public abstract class BaseSourceWithKeyRange<T> implements ParallelSourceFunction<T> {
diff --git a/src/main/java/org/apache/flink/benchmark/functions/IntegerLongSource.java b/src/main/java/org/apache/flink/benchmark/functions/IntegerLongSource.java
index aeddfa3..22ad2f9 100644
--- a/src/main/java/org/apache/flink/benchmark/functions/IntegerLongSource.java
+++ b/src/main/java/org/apache/flink/benchmark/functions/IntegerLongSource.java
@@ -18,7 +18,7 @@
 
 package org.apache.flink.benchmark.functions;
 
-import org.apache.flink.streaming.api.functions.source.RichParallelSourceFunction;
+import org.apache.flink.streaming.api.functions.source.legacy.RichParallelSourceFunction;
 
 public class IntegerLongSource extends RichParallelSourceFunction<IntegerLongSource.Record> {
     private volatile boolean running = true;
diff --git a/src/main/java/org/apache/flink/benchmark/functions/LongSource.java b/src/main/java/org/apache/flink/benchmark/functions/LongSource.java
index 36478c3..985dd39 100644
--- a/src/main/java/org/apache/flink/benchmark/functions/LongSource.java
+++ b/src/main/java/org/apache/flink/benchmark/functions/LongSource.java
@@ -18,7 +18,7 @@
 
 package org.apache.flink.benchmark.functions;
 
-import org.apache.flink.streaming.api.functions.source.RichParallelSourceFunction;
+import org.apache.flink.streaming.api.functions.source.legacy.RichParallelSourceFunction;
 
 public class LongSource extends RichParallelSourceFunction<Long> {
 
diff --git a/src/main/java/org/apache/flink/state/benchmark/RescalingBenchmarkBase.java b/src/main/java/org/apache/flink/state/benchmark/RescalingBenchmarkBase.java
index be25fd7..f5b749d 100644
--- a/src/main/java/org/apache/flink/state/benchmark/RescalingBenchmarkBase.java
+++ b/src/main/java/org/apache/flink/state/benchmark/RescalingBenchmarkBase.java
@@ -17,6 +17,7 @@
  */
 package org.apache.flink.state.benchmark;
 
+import org.apache.flink.api.common.functions.OpenContext;
 import org.apache.flink.api.common.state.ValueState;
 import org.apache.flink.api.common.state.ValueStateDescriptor;
 import org.apache.flink.api.common.typeinfo.PrimitiveArrayTypeInfo;
@@ -156,8 +157,8 @@ public class RescalingBenchmarkBase extends BenchmarkBase {
         private final byte[] stateArray = new byte[valueLen];
 
         @Override
-        public void open(Configuration parameters) throws Exception {
-            super.open(parameters);
+        public void open(OpenContext openContext) throws Exception {
+            super.open(openContext);
             randomState =
                     this.getRuntimeContext()
                             .getState(new ValueStateDescriptor<>("RandomState", byte[].class));
diff --git a/src/main/java/org/apache/flink/state/benchmark/StateBenchmarkBase.java b/src/main/java/org/apache/flink/state/benchmark/StateBenchmarkBase.java
index 345063c..8c1f970 100644
--- a/src/main/java/org/apache/flink/state/benchmark/StateBenchmarkBase.java
+++ b/src/main/java/org/apache/flink/state/benchmark/StateBenchmarkBase.java
@@ -72,7 +72,7 @@ public class StateBenchmarkBase extends BenchmarkBase {
 
     public static File createStateDataDir() throws IOException {
         Configuration benchMarkConfig = ConfigUtil.loadBenchMarkConf();
-        String stateDataDirPath = benchMarkConfig.getString(StateBenchmarkOptions.STATE_DATA_DIR);
+        String stateDataDirPath = benchMarkConfig.get(StateBenchmarkOptions.STATE_DATA_DIR);
         File dataDir = null;
         if (stateDataDirPath != null) {
             dataDir = new File(stateDataDirPath);
diff --git a/src/test/java/org/apache/flink/config/ConfigUtilTest.java b/src/test/java/org/apache/flink/config/ConfigUtilTest.java
index 9f3cbaa..a1b8324 100644
--- a/src/test/java/org/apache/flink/config/ConfigUtilTest.java
+++ b/src/test/java/org/apache/flink/config/ConfigUtilTest.java
@@ -28,7 +28,7 @@ public class ConfigUtilTest {
     @Test
     public void testLoadConf() {
         Configuration cfg = ConfigUtil.loadBenchMarkConf();
-        String dir = cfg.getString(StateBenchmarkOptions.STATE_DATA_DIR);
+        String dir = cfg.get(StateBenchmarkOptions.STATE_DATA_DIR);
         Assert.assertEquals("/tmp/data", dir);
     }
 }