diff --git a/benches/hierarchy/mvcc/mod.rs b/benches/hierarchy/mvcc/mod.rs
index a068bd18eca..833301f5368 100644
--- a/benches/hierarchy/mvcc/mod.rs
+++ b/benches/hierarchy/mvcc/mod.rs
@@ -9,6 +9,36 @@ use tikv::storage::{Key, Mutation, Options};
 
 use super::{BenchConfig, EngineFactory, DEFAULT_ITERATIONS, DEFAULT_KV_GENERATOR_SEED};
 
+fn setup_prewrite<E, F>(engine: &E, config: &BenchConfig<F>, start_ts: u64) -> (E::Snap, Vec<Key>)
+where
+    E: Engine,
+    F: EngineFactory<E>,
+{
+    let ctx = Context::new();
+    let snapshot = engine.snapshot(&ctx).unwrap();
+    let mut txn = MvccTxn::new(snapshot, start_ts, true).unwrap();
+
+    let kvs = KvGenerator::with_seed(
+        config.key_length,
+        config.value_length,
+        DEFAULT_KV_GENERATOR_SEED,
+    )
+    .generate(DEFAULT_ITERATIONS);
+    for (k, v) in &kvs {
+        txn.prewrite(
+            Mutation::Put((Key::from_raw(&k), v.clone())),
+            &k.clone(),
+            &Options::default(),
+        )
+        .unwrap();
+    }
+    let modifies = txn.into_modifies();
+    let _ = engine.async_write(&ctx, modifies, Box::new(move |(_, _)| {}));
+    let keys: Vec<Key> = kvs.iter().map(|(k, _)| Key::from_raw(&k)).collect();
+    let snapshot = engine.snapshot(&ctx).unwrap();
+    (snapshot, keys)
+}
+
 fn mvcc_prewrite<E: Engine, F: EngineFactory<E>>(b: &mut Bencher, config: &BenchConfig<F>) {
     let engine = config.engine_factory.build();
     let ctx = Context::new();
@@ -38,30 +68,67 @@ fn mvcc_prewrite<E: Engine, F: EngineFactory<E>>(b: &mut Bencher, config: &Bench
 }
 
 fn mvcc_commit<E: Engine, F: EngineFactory<E>>(b: &mut Bencher, config: &BenchConfig<F>) {
+    let engine = config.engine_factory.build();
+    b.iter_batched(
+        || setup_prewrite(&engine, &config, 1),
+        |(snapshot, keys)| {
+            for key in keys {
+                let mut txn = MvccTxn::new(snapshot.clone(), 1, true).unwrap();
+                black_box(txn.commit(key, 1)).unwrap();
+            }
+        },
+        BatchSize::SmallInput,
+    );
+}
+
+fn mvcc_rollback_prewrote<E: Engine, F: EngineFactory<E>>(
+    b: &mut Bencher,
+    config: &BenchConfig<F>,
+) {
+    let engine = config.engine_factory.build();
+    b.iter_batched(
+        || setup_prewrite(&engine, &config, 1),
+        |(snapshot, keys)| {
+            for key in keys {
+                let mut txn = MvccTxn::new(snapshot.clone(), 1, true).unwrap();
+                black_box(txn.rollback(key)).unwrap();
+            }
+        },
+        BatchSize::SmallInput,
+    )
+}
+
+fn mvcc_rollback_conflict<E: Engine, F: EngineFactory<E>>(
+    b: &mut Bencher,
+    config: &BenchConfig<F>,
+) {
+    let engine = config.engine_factory.build();
+    b.iter_batched(
+        || setup_prewrite(&engine, &config, 2),
+        |(snapshot, keys)| {
+            for key in keys {
+                let mut txn = MvccTxn::new(snapshot.clone(), 1, true).unwrap();
+                black_box(txn.rollback(key)).unwrap();
+            }
+        },
+        BatchSize::SmallInput,
+    )
+}
+
+fn mvcc_rollback_non_prewrote<E: Engine, F: EngineFactory<E>>(
+    b: &mut Bencher,
+    config: &BenchConfig<F>,
+) {
     let engine = config.engine_factory.build();
     let ctx = Context::new();
-    let snapshot = engine.snapshot(&ctx).unwrap();
-    let option = Options::default();
     b.iter_batched(
         || {
-            let mut txn = MvccTxn::new(snapshot.clone(), 1, true).unwrap();
-
             let kvs = KvGenerator::with_seed(
                 config.key_length,
                 config.value_length,
                 DEFAULT_KV_GENERATOR_SEED,
             )
             .generate(DEFAULT_ITERATIONS);
-            for (k, v) in &kvs {
-                txn.prewrite(
-                    Mutation::Put((Key::from_raw(&k), v.clone())),
-                    &k.clone(),
-                    &option,
-                )
-                .unwrap();
-            }
-            let modifies = txn.into_modifies();
-            let _ = engine.async_write(&ctx, modifies, Box::new(move |(_, _)| {}));
             let keys: Vec<Key> = kvs.iter().map(|(k, _)| Key::from_raw(&k)).collect();
             let snapshot = engine.snapshot(&ctx).unwrap();
             (snapshot, keys)
@@ -69,11 +136,11 @@ fn mvcc_commit<E: Engine, F: EngineFactory<E>>(b: &mut Bencher, config: &BenchCo
         |(snapshot, keys)| {
             for key in keys {
                 let mut txn = MvccTxn::new(snapshot.clone(), 1, true).unwrap();
-                black_box(txn.commit(key, 1)).unwrap();
+                black_box(txn.rollback(key)).unwrap();
             }
         },
         BatchSize::SmallInput,
-    );
+    )
 }
 
 fn mvcc_reader_load_lock<E: Engine, F: EngineFactory<E>>(b: &mut Bencher, config: &BenchConfig<F>) {
@@ -151,6 +218,21 @@ fn mvcc_reader_seek_write<E: Engine, F: EngineFactory<E>>(
 pub fn bench_mvcc<E: Engine, F: EngineFactory<E>>(c: &mut Criterion, configs: &[BenchConfig<F>]) {
     c.bench_function_over_inputs("mvcc_prewrite", mvcc_prewrite, configs.to_owned());
     c.bench_function_over_inputs("mvcc_commit", mvcc_commit, configs.to_owned());
+    c.bench_function_over_inputs(
+        "mvcc_rollback_prewrote",
+        mvcc_rollback_prewrote,
+        configs.to_owned(),
+    );
+    c.bench_function_over_inputs(
+        "mvcc_rollback_conflict",
+        mvcc_rollback_conflict,
+        configs.to_owned(),
+    );
+    c.bench_function_over_inputs(
+        "mvcc_rollback_non_prewrote",
+        mvcc_rollback_non_prewrote,
+        configs.to_owned(),
+    );
     c.bench_function_over_inputs("mvcc_load_lock", mvcc_reader_load_lock, configs.to_owned());
     c.bench_function_over_inputs(
         "mvcc_seek_write",
diff --git a/benches/hierarchy/txn/mod.rs b/benches/hierarchy/txn/mod.rs
index d94d73fe79e..e0273f47b8e 100644
--- a/benches/hierarchy/txn/mod.rs
+++ b/benches/hierarchy/txn/mod.rs
@@ -9,6 +9,31 @@ use tikv::storage::{Key, Mutation, Options};
 
 use super::{BenchConfig, EngineFactory, DEFAULT_ITERATIONS};
 
+fn setup_prewrite<E, F>(engine: &E, config: &BenchConfig<F>, start_ts: u64) -> Vec<Key>
+where
+    E: Engine,
+    F: EngineFactory<E>,
+{
+    let ctx = Context::new();
+    let option = Options::default();
+
+    let snapshot = engine.snapshot(&ctx).unwrap();
+    let mut txn = MvccTxn::new(snapshot, start_ts, true).unwrap();
+    let kvs = KvGenerator::new(config.key_length, config.value_length).generate(DEFAULT_ITERATIONS);
+    for (k, v) in &kvs {
+        txn.prewrite(
+            Mutation::Put((Key::from_raw(&k), v.clone())),
+            &k.clone(),
+            &option,
+        )
+        .unwrap();
+    }
+    let modifies = txn.into_modifies();
+    let _ = engine.write(&ctx, modifies);
+    let keys: Vec<Key> = kvs.iter().map(|(k, _)| Key::from_raw(&k)).collect();
+    keys
+}
+
 fn txn_prewrite<E: Engine, F: EngineFactory<E>>(b: &mut Bencher, config: &BenchConfig<F>) {
     let engine = config.engine_factory.build();
     let ctx = Context::new();
@@ -39,23 +64,67 @@ fn txn_prewrite<E: Engine, F: EngineFactory<E>>(b: &mut Bencher, config: &BenchC
 fn txn_commit<E: Engine, F: EngineFactory<E>>(b: &mut Bencher, config: &BenchConfig<F>) {
     let engine = config.engine_factory.build();
     let ctx = Context::new();
-    let option = Options::default();
+    b.iter_batched(
+        || setup_prewrite(&engine, &config, 1),
+        |keys| {
+            for key in keys {
+                let snapshot = engine.snapshot(&ctx).unwrap();
+                let mut txn = MvccTxn::new(snapshot, 1, true).unwrap();
+                txn.commit(key, 2).unwrap();
+                let modifies = txn.into_modifies();
+                black_box(engine.write(&ctx, modifies)).unwrap();
+            }
+        },
+        BatchSize::SmallInput,
+    );
+}
+
+fn txn_rollback_prewrote<E: Engine, F: EngineFactory<E>>(b: &mut Bencher, config: &BenchConfig<F>) {
+    let engine = config.engine_factory.build();
+    let ctx = Context::new();
+    b.iter_batched(
+        || setup_prewrite(&engine, &config, 1),
+        |keys| {
+            for key in keys {
+                let snapshot = engine.snapshot(&ctx).unwrap();
+                let mut txn = MvccTxn::new(snapshot, 1, true).unwrap();
+                txn.rollback(key).unwrap();
+                let modifies = txn.into_modifies();
+                black_box(engine.write(&ctx, modifies)).unwrap();
+            }
+        },
+        BatchSize::SmallInput,
+    )
+}
+
+fn txn_rollback_conflict<E: Engine, F: EngineFactory<E>>(b: &mut Bencher, config: &BenchConfig<F>) {
+    let engine = config.engine_factory.build();
+    let ctx = Context::new();
+    b.iter_batched(
+        || setup_prewrite(&engine, &config, 2),
+        |keys| {
+            for key in keys {
+                let snapshot = engine.snapshot(&ctx).unwrap();
+                let mut txn = MvccTxn::new(snapshot, 1, true).unwrap();
+                txn.rollback(key).unwrap();
+                let modifies = txn.into_modifies();
+                black_box(engine.write(&ctx, modifies)).unwrap();
+            }
+        },
+        BatchSize::SmallInput,
+    )
+}
+
+fn txn_rollback_non_prewrote<E: Engine, F: EngineFactory<E>>(
+    b: &mut Bencher,
+    config: &BenchConfig<F>,
+) {
+    let engine = config.engine_factory.build();
+    let ctx = Context::new();
     b.iter_batched(
         || {
-            let snapshot = engine.snapshot(&ctx).unwrap();
-            let mut txn = MvccTxn::new(snapshot, 1, true).unwrap();
             let kvs = KvGenerator::new(config.key_length, config.value_length)
                 .generate(DEFAULT_ITERATIONS);
-            for (k, v) in &kvs {
-                txn.prewrite(
-                    Mutation::Put((Key::from_raw(&k), v.clone())),
-                    &k.clone(),
-                    &option,
-                )
-                .unwrap();
-            }
-            let modifies = txn.into_modifies();
-            let _ = engine.write(&ctx, modifies);
             let keys: Vec<Key> = kvs.iter().map(|(k, _)| Key::from_raw(&k)).collect();
             keys
         },
@@ -63,16 +132,31 @@ fn txn_commit<E: Engine, F: EngineFactory<E>>(b: &mut Bencher, config: &BenchCon
             for key in keys {
                 let snapshot = engine.snapshot(&ctx).unwrap();
                 let mut txn = MvccTxn::new(snapshot, 1, true).unwrap();
-                txn.commit(key, 2).unwrap();
+                txn.rollback(key).unwrap();
                 let modifies = txn.into_modifies();
                 black_box(engine.write(&ctx, modifies)).unwrap();
             }
         },
         BatchSize::SmallInput,
-    );
+    )
 }
 
 pub fn bench_txn<E: Engine, F: EngineFactory<E>>(c: &mut Criterion, configs: &[BenchConfig<F>]) {
     c.bench_function_over_inputs("txn_prewrite", txn_prewrite, configs.to_owned());
     c.bench_function_over_inputs("txn_commit", txn_commit, configs.to_owned());
+    c.bench_function_over_inputs(
+        "txn_rollback_prewrote",
+        txn_rollback_prewrote,
+        configs.to_owned(),
+    );
+    c.bench_function_over_inputs(
+        "txn_rollback_conflict",
+        txn_rollback_conflict,
+        configs.to_owned(),
+    );
+    c.bench_function_over_inputs(
+        "txn_rollback_non_prewrote",
+        txn_rollback_non_prewrote,
+        configs.to_owned(),
+    );
 }