diff --git a/redisson/src/main/java/org/redisson/RedissonBitSet.java b/redisson/src/main/java/org/redisson/RedissonBitSet.java
index 9ca590493c1..4b90271ea60 100644
--- a/redisson/src/main/java/org/redisson/RedissonBitSet.java
+++ b/redisson/src/main/java/org/redisson/RedissonBitSet.java
@@ -24,6 +24,7 @@
 import org.redisson.api.RBitSet;
 import org.redisson.api.RFuture;
 import org.redisson.client.codec.ByteArrayCodec;
+import org.redisson.client.protocol.RedisCommand;
 import org.redisson.client.protocol.RedisCommands;
 import org.redisson.command.CommandAsyncExecutor;
 import org.redisson.command.CommandBatchService;
@@ -80,8 +81,12 @@ public void set(long bitIndex, boolean value) {
     }
 
     @Override
-    public RFuture<Void> setAsync(long bitIndex, boolean value) {
-        return commandExecutor.writeAsync(getName(), codec, RedisCommands.SETBIT_VOID, getName(), bitIndex, value ? 1 : 0);
+    public RFuture<Boolean> setAsync(long bitIndex, boolean value) {
+        RedisCommand<Boolean> command = RedisCommands.SETBIT_TRUE;
+        if (!value) {
+            command = RedisCommands.SETBIT_FALSE;
+        }
+        return commandExecutor.writeAsync(getName(), codec, command, getName(), bitIndex, value ? 1 : 0);
     }
 
     @Override
@@ -100,7 +105,7 @@ public long cardinality() {
     }
 
     @Override
-    public int size() {
+    public long size() {
         return get(sizeAsync());
     }
 
@@ -110,8 +115,8 @@ public void clear(long fromIndex, long toIndex) {
     }
 
     @Override
-    public void clear(long bitIndex) {
-        get(clearAsync(bitIndex));
+    public boolean clear(long bitIndex) {
+        return get(clearAsync(bitIndex));
     }
 
     @Override
@@ -232,12 +237,12 @@ public RFuture<Void> setAsync(long fromIndex, long toIndex) {
     }
 
     @Override
-    public RFuture<Integer> sizeAsync() {
+    public RFuture<Long> sizeAsync() {
         return commandExecutor.readAsync(getName(), codec, RedisCommands.BITS_SIZE, getName());
     }
 
     @Override
-    public RFuture<Void> setAsync(long bitIndex) {
+    public RFuture<Boolean> setAsync(long bitIndex) {
         return setAsync(bitIndex, true);
     }
 
@@ -247,7 +252,7 @@ public RFuture<Long> cardinalityAsync() {
     }
 
     @Override
-    public RFuture<Void> clearAsync(long bitIndex) {
+    public RFuture<Boolean> clearAsync(long bitIndex) {
         return setAsync(bitIndex, false);
     }
 
diff --git a/redisson/src/main/java/org/redisson/RedissonBloomFilter.java b/redisson/src/main/java/org/redisson/RedissonBloomFilter.java
index becf61f5d24..b5f474d5f34 100644
--- a/redisson/src/main/java/org/redisson/RedissonBloomFilter.java
+++ b/redisson/src/main/java/org/redisson/RedissonBloomFilter.java
@@ -20,6 +20,7 @@
 import java.util.List;
 import java.util.Map;
 
+import org.redisson.api.RBitSetAsync;
 import org.redisson.api.RBloomFilter;
 import org.redisson.api.RFuture;
 import org.redisson.client.RedisException;
@@ -104,8 +105,9 @@ public boolean add(T object) {
 
             CommandBatchService executorService = new CommandBatchService(commandExecutor.getConnectionManager());
             addConfigCheck(hashIterations, size, executorService);
+            RBitSetAsync bs = createBitSet(executorService);
             for (int i = 0; i < indexes.length; i++) {
-                executorService.writeAsync(getName(), codec, RedisCommands.SETBIT, getName(), indexes[i], 1);
+                bs.setAsync(indexes[i]);
             }
             try {
                 List<Boolean> result = (List<Boolean>) executorService.execute();
@@ -154,8 +156,9 @@ public boolean contains(T object) {
 
             CommandBatchService executorService = new CommandBatchService(commandExecutor.getConnectionManager());
             addConfigCheck(hashIterations, size, executorService);
+            RBitSetAsync bs = createBitSet(executorService);
             for (int i = 0; i < indexes.length; i++) {
-                executorService.readAsync(getName(), codec, RedisCommands.GETBIT, getName(), indexes[i]);
+                bs.getAsync(indexes[i]);
             }
             try {
                 List<Boolean> result = (List<Boolean>) executorService.execute();
@@ -175,6 +178,10 @@ public boolean contains(T object) {
         }
     }
 
+    protected RBitSetAsync createBitSet(CommandBatchService executorService) {
+        return new RedissonBitSet(executorService, getName());
+    }
+
     private void addConfigCheck(int hashIterations, long size, CommandBatchService executorService) {
         executorService.evalReadAsync(getConfigName(), codec, RedisCommands.EVAL_VOID,
                 "local size = redis.call('hget', KEYS[1], 'size');" +
@@ -188,7 +195,8 @@ public int count() {
         CommandBatchService executorService = new CommandBatchService(commandExecutor.getConnectionManager());
         RFuture<Map<String, String>> configFuture = executorService.readAsync(getConfigName(), StringCodec.INSTANCE,
                 new RedisCommand<Map<Object, Object>>("HGETALL", new ObjectMapReplayDecoder()), getConfigName());
-        RFuture<Long> cardinalityFuture = executorService.readAsync(getName(), codec, RedisCommands.BITCOUNT, getName());
+        RBitSetAsync bs = createBitSet(executorService);
+        RFuture<Long> cardinalityFuture = bs.cardinalityAsync();
         executorService.execute();
 
         readConfig(configFuture.getNow());
@@ -260,7 +268,7 @@ public boolean tryInit(long expectedInsertions, double falseProbability) {
     }
 
     private String getConfigName() {
-        return "{" + getName() + "}" + "__config";
+        return suffixName(getName(), "config");
     }
 
     @Override
diff --git a/redisson/src/main/java/org/redisson/api/RBitSet.java b/redisson/src/main/java/org/redisson/api/RBitSet.java
index 523325ac59c..b6b60d8530a 100644
--- a/redisson/src/main/java/org/redisson/api/RBitSet.java
+++ b/redisson/src/main/java/org/redisson/api/RBitSet.java
@@ -37,7 +37,7 @@ public interface RBitSet extends RExpirable, RBitSetAsync {
 
     void set(long fromIndex, long toIndex);
 
-    int size();
+    long size();
 
     boolean get(long bitIndex);
 
@@ -49,7 +49,7 @@ public interface RBitSet extends RExpirable, RBitSetAsync {
 
     long cardinality();
 
-    void clear(long bitIndex);
+    boolean clear(long bitIndex);
 
     void clear();
 
diff --git a/redisson/src/main/java/org/redisson/api/RBitSetAsync.java b/redisson/src/main/java/org/redisson/api/RBitSetAsync.java
index 92e2d385934..55a422a5590 100644
--- a/redisson/src/main/java/org/redisson/api/RBitSetAsync.java
+++ b/redisson/src/main/java/org/redisson/api/RBitSetAsync.java
@@ -39,17 +39,17 @@ public interface RBitSetAsync extends RExpirableAsync {
 
     RFuture<Void> setAsync(long fromIndex, long toIndex);
 
-    RFuture<Integer> sizeAsync();
+    RFuture<Long> sizeAsync();
 
     RFuture<Boolean> getAsync(long bitIndex);
 
-    RFuture<Void> setAsync(long bitIndex);
+    RFuture<Boolean> setAsync(long bitIndex);
 
-    RFuture<Void> setAsync(long bitIndex, boolean value);
+    RFuture<Boolean> setAsync(long bitIndex, boolean value);
 
     RFuture<Long> cardinalityAsync();
 
-    RFuture<Void> clearAsync(long bitIndex);
+    RFuture<Boolean> clearAsync(long bitIndex);
 
     RFuture<Void> clearAsync();
 
diff --git a/redisson/src/main/java/org/redisson/api/RBitSetReactive.java b/redisson/src/main/java/org/redisson/api/RBitSetReactive.java
index bde2c71065f..9850c68ca19 100644
--- a/redisson/src/main/java/org/redisson/api/RBitSetReactive.java
+++ b/redisson/src/main/java/org/redisson/api/RBitSetReactive.java
@@ -42,17 +42,17 @@ public interface RBitSetReactive extends RExpirableReactive {
 
     Publisher<Void> set(long fromIndex, long toIndex);
 
-    Publisher<Integer> size();
+    Publisher<Long> size();
 
     Publisher<Boolean> get(long bitIndex);
 
-    Publisher<Void> set(long bitIndex);
+    Publisher<Boolean> set(long bitIndex);
 
-    Publisher<Void> set(long bitIndex, boolean value);
+    Publisher<Boolean> set(long bitIndex, boolean value);
 
     Publisher<Long> cardinality();
 
-    Publisher<Void> clear(long bitIndex);
+    Publisher<Boolean> clear(long bitIndex);
 
     Publisher<Void> clear();
 
diff --git a/redisson/src/main/java/org/redisson/client/protocol/RedisCommands.java b/redisson/src/main/java/org/redisson/client/protocol/RedisCommands.java
index 773c37f87e7..48299979a3b 100644
--- a/redisson/src/main/java/org/redisson/client/protocol/RedisCommands.java
+++ b/redisson/src/main/java/org/redisson/client/protocol/RedisCommands.java
@@ -86,12 +86,13 @@ public interface RedisCommands {
     RedisStrictCommand<RType> TYPE = new RedisStrictCommand<RType>("TYPE", new TypeConvertor());
 
     RedisStrictCommand<Boolean> GETBIT = new RedisStrictCommand<Boolean>("GETBIT", new BooleanReplayConvertor());
-    RedisStrictCommand<Integer> BITS_SIZE = new RedisStrictCommand<Integer>("STRLEN", new BitsSizeReplayConvertor());
+    RedisStrictCommand<Long> BITS_SIZE = new RedisStrictCommand<Long>("STRLEN", new BitsSizeReplayConvertor());
     RedisStrictCommand<Long> STRLEN = new RedisStrictCommand<Long>("STRLEN");
     RedisStrictCommand<Long> BITCOUNT = new RedisStrictCommand<Long>("BITCOUNT");
     RedisStrictCommand<Integer> BITPOS = new RedisStrictCommand<Integer>("BITPOS", new IntegerReplayConvertor());
     RedisStrictCommand<Void> SETBIT_VOID = new RedisStrictCommand<Void>("SETBIT", new VoidReplayConvertor());
-    RedisStrictCommand<Boolean> SETBIT = new RedisStrictCommand<Boolean>("SETBIT", new BitSetReplayConvertor());
+    RedisStrictCommand<Boolean> SETBIT_TRUE = new RedisStrictCommand<Boolean>("SETBIT", new BitSetReplayConvertor(0));
+    RedisStrictCommand<Boolean> SETBIT_FALSE = new RedisStrictCommand<Boolean>("SETBIT", new BitSetReplayConvertor(1));
     RedisStrictCommand<Void> BITOP = new RedisStrictCommand<Void>("BITOP", new VoidReplayConvertor());
 
     RedisStrictCommand<Integer> WAIT = new RedisStrictCommand<Integer>("WAIT", new IntegerReplayConvertor());
diff --git a/redisson/src/main/java/org/redisson/client/protocol/convertor/BitSetReplayConvertor.java b/redisson/src/main/java/org/redisson/client/protocol/convertor/BitSetReplayConvertor.java
index 1f901d0d090..6975ac04606 100644
--- a/redisson/src/main/java/org/redisson/client/protocol/convertor/BitSetReplayConvertor.java
+++ b/redisson/src/main/java/org/redisson/client/protocol/convertor/BitSetReplayConvertor.java
@@ -15,11 +15,23 @@
  */
 package org.redisson.client.protocol.convertor;
 
+/**
+ * 
+ * @author Nikita Koksharov
+ *
+ */
 public class BitSetReplayConvertor extends SingleConvertor<Boolean> {
 
+    private final int expectedValue;
+    
+    public BitSetReplayConvertor(int expectedValue) {
+        super();
+        this.expectedValue = expectedValue;
+    }
+
     @Override
     public Boolean convert(Object obj) {
-        return Long.valueOf(0).equals(obj);
+        return expectedValue == (Long)obj;
     }
 
 
diff --git a/redisson/src/main/java/org/redisson/client/protocol/convertor/BitsSizeReplayConvertor.java b/redisson/src/main/java/org/redisson/client/protocol/convertor/BitsSizeReplayConvertor.java
index 03ddd87f7ea..e7f1640aa67 100644
--- a/redisson/src/main/java/org/redisson/client/protocol/convertor/BitsSizeReplayConvertor.java
+++ b/redisson/src/main/java/org/redisson/client/protocol/convertor/BitsSizeReplayConvertor.java
@@ -15,15 +15,14 @@
  */
 package org.redisson.client.protocol.convertor;
 
-public class BitsSizeReplayConvertor extends SingleConvertor<Integer> {
+public class BitsSizeReplayConvertor extends SingleConvertor<Long> {
 
     @Override
-    public Integer convert(Object obj) {
+    public Long convert(Object obj) {
         if (obj == null) {
             return null;
         }
-        int val = ((Long) obj).intValue();
-        return val * 8;
+        return ((Long) obj) * 8;
     }
 
 }
diff --git a/redisson/src/main/java/org/redisson/reactive/RedissonBitSetReactive.java b/redisson/src/main/java/org/redisson/reactive/RedissonBitSetReactive.java
index 97d4ebdc791..806a83c5aa2 100644
--- a/redisson/src/main/java/org/redisson/reactive/RedissonBitSetReactive.java
+++ b/redisson/src/main/java/org/redisson/reactive/RedissonBitSetReactive.java
@@ -51,10 +51,10 @@ public RFuture<Boolean> get() {
         });
     }
 
-    public Publisher<Void> set(final long bitIndex, final boolean value) {
-        return reactive(new Supplier<RFuture<Void>>() {
+    public Publisher<Boolean> set(final long bitIndex, final boolean value) {
+        return reactive(new Supplier<RFuture<Boolean>>() {
             @Override
-            public RFuture<Void> get() {
+            public RFuture<Boolean> get() {
                 return instance.setAsync(bitIndex, value);
             }
         });
@@ -134,20 +134,20 @@ public RFuture<Void> get() {
     }
 
     @Override
-    public Publisher<Integer> size() {
-        return reactive(new Supplier<RFuture<Integer>>() {
+    public Publisher<Long> size() {
+        return reactive(new Supplier<RFuture<Long>>() {
             @Override
-            public RFuture<Integer> get() {
+            public RFuture<Long> get() {
                 return instance.sizeAsync();
             }
         });
     }
 
     @Override
-    public Publisher<Void> set(final long bitIndex) {
-        return reactive(new Supplier<RFuture<Void>>() {
+    public Publisher<Boolean> set(final long bitIndex) {
+        return reactive(new Supplier<RFuture<Boolean>>() {
             @Override
-            public RFuture<Void> get() {
+            public RFuture<Boolean> get() {
                 return instance.setAsync(bitIndex);
             }
         });
@@ -164,10 +164,10 @@ public RFuture<Long> get() {
     }
 
     @Override
-    public Publisher<Void> clear(final long bitIndex) {
-        return reactive(new Supplier<RFuture<Void>>() {
+    public Publisher<Boolean> clear(final long bitIndex) {
+        return reactive(new Supplier<RFuture<Boolean>>() {
             @Override
-            public RFuture<Void> get() {
+            public RFuture<Boolean> get() {
                 return instance.clearAsync(bitIndex);
             }
         });