Example #1
0
        public void RedisClusterPerformance()
        {
            var n       = 30000;
            var errRate = 0.01;

            var hashData = Helper.GenerateData(n);

            var configuration = "127.0.0.1:7000,127.0.0.1:7001,127.0.0.1:7002,127.0.0.1:7003,127.0.0.1:7004,127.0.0.1:7005";

            var conn = ConnectionMultiplexer.Connect(configuration);

            foreach (var entry in conn.GetEndPoints())
            {
                var server = conn.GetServer(entry);
                Console.WriteLine(server.EndPoint + " " + server.ServerType);
            }
            conn.Dispose();

            var names = Enum.GetNames(typeof(HashMethod));

            foreach (var name in names)
            {
                if (Enum.TryParse <HashMethod>(name, out var hm))
                {
                    var bf = FilterRedisBuilder.Build(configuration, "bftest", n, errRate, hm);
                    bf.Clear();
                    Console.WriteLine($"=================== {name} Performance =================== ");
                    Performance(hashData, bf);
                    bf.Dispose();
                }
            }
        }
        public void BytesArrayTest(HashMethod hashMethod)
        {
            var bf = FilterRedisBuilder.Build("localhost", "BytesArrayTest", 10000, 0.01, hashMethod);

            var rng = RandomNumberGenerator.Create();

            var len  = 10;
            var list = new List <byte[]>(len);

            for (int i = 0; i < len; i++)
            {
                var data = new byte[1024];
                rng.GetBytes(data);
                list.Add(data);
            }

            Assert.All(bf.Add(list), r => Assert.True(r));
            Assert.All(bf.Contains(list), r => Assert.True(r));

            Assert.True(bf.All(list));

            bf.Clear();

            Assert.All(bf.Contains(list), r => Assert.False(r));
            Assert.False(bf.All(list));
        }
Example #3
0
        public void RedisPerformance()
        {
            var n       = 30000;
            var errRate = 0.01;

            var hashData = Helper.GenerateData(n);

            var warm_up = FilterRedisBuilder.Build("localhost", "RedisPerformance", n, errRate);

            warm_up.Clear();
            Console.WriteLine($"=================== warm_up Performance =================== ");
            Performance(hashData, warm_up);

            var names = Enum.GetNames(typeof(HashMethod));

            foreach (var name in names)
            {
                if (Enum.TryParse <HashMethod>(name, out var hm))
                {
                    var bf = FilterRedisBuilder.Build("localhost", "RedisPerformance", n, errRate, hm);
                    bf.Clear();
                    Console.WriteLine($"=================== {name} Performance =================== ");
                    Performance(hashData, bf);
                }
            }
        }
Example #4
0
        public void Setup()
        {
            var n       = 1000000;
            var errRate = 0.01;

            data   = Helper.GenerateBytes(DataSize);
            filter = FilterRedisBuilder.Build("localhost", "RedisBloomFilterTest", n, errRate, HashMethod.Murmur3KirschMitzenmacher);
            filter.Clear();
        }
        public void SampleInRedis()
        {
            var names = Enum.GetNames(typeof(HashMethod));

            foreach (var name in names)
            {
                if (Enum.TryParse <HashMethod>(name, out var hm))
                {
                    var bf = FilterRedisBuilder.Build <string>("localhost", "bftest", 5000000, 0.001, hm);
                    Sample(bf);
                }
            }
        }
        public void NormalTest(HashMethod hashMethod)
        {
            var bf = FilterRedisBuilder.Build <string>("localhost", "NormalTest", 10000, 0.01, hashMethod);

            var len   = 10;
            var array = new string[len];

            for (int i = 0; i < len; i++)
            {
                array[i] = Utilitiy.GenerateString(10);
            }

            Assert.All(bf.Add(array), r => Assert.True(r));
            Assert.All(bf.Contains(array), r => Assert.True(r));

            Assert.True(bf.All(array));

            bf.Clear();

            Assert.All(bf.Contains(array), r => Assert.False(r));
            Assert.False(bf.All(array));
        }
        public async Task NormalTestAsync(HashMethod hashMethod)
        {
            var bf = FilterRedisBuilder.Build("localhost", "NormalTestAsync", 10000, 0.01, hashMethod);

            var len   = 10;
            var array = new string[len];

            for (int i = 0; i < len; i++)
            {
                array[i] = Utilitiy.GenerateString(10);
            }

            Assert.All(await bf.AddAsync(array), r => Assert.True(r));
            Assert.All(await bf.ContainsAsync(array), r => Assert.True(r));

            Assert.True(await bf.AllAsync(array));

            await bf.ClearAsync();

            Assert.All(await bf.ContainsAsync(array), r => Assert.False(r));
            Assert.False(await bf.AllAsync(array));
        }
        public void BuildTest()
        {
            var hashFun = new HashAlgorithms.HashCryptoMD5();
            var config  = ConfigurationOptions.Parse("localhost");
            var conn    = ConnectionMultiplexer.Connect(config);
            var operate = new RedisBitOperate(conn);

            buildTest(FilterRedisBuilder.Build <string>(config, "BuildTest", 10000));
            buildTest(FilterRedisBuilder.Build <string>(config, "BuildTest", 10000, hashFun));
            buildTest(FilterRedisBuilder.Build <string>(config, "BuildTest", 10000, HashMethod.Adler32));
            buildTest(FilterRedisBuilder.Build <string>(config, "BuildTest", 10000, 0.01));
            buildTest(FilterRedisBuilder.Build <string>(config, "BuildTest", 10000, 0.01, hashFun));
            buildTest(FilterRedisBuilder.Build <string>(config, "BuildTest", 10000, 0.01, HashMethod.Adler32));

            buildTest(FilterRedisBuilder.Build <string>("localhost", "BuildTest", 10000));
            buildTest(FilterRedisBuilder.Build <string>("localhost", "BuildTest", 10000, hashFun));
            buildTest(FilterRedisBuilder.Build <string>("localhost", "BuildTest", 10000, HashMethod.Adler32));
            buildTest(FilterRedisBuilder.Build <string>("localhost", "BuildTest", 10000, 0.01));
            buildTest(FilterRedisBuilder.Build <string>("localhost", "BuildTest", 10000, 0.01, hashFun));
            buildTest(FilterRedisBuilder.Build <string>("localhost", "BuildTest", 10000, 0.01, HashMethod.Adler32));

            buildTest(FilterRedisBuilder.Build <string>(conn, "BuildTest", 10000));
            buildTest(FilterRedisBuilder.Build <string>(conn, "BuildTest", 10000, hashFun));
            buildTest(FilterRedisBuilder.Build <string>(conn, "BuildTest", 10000, HashMethod.Adler32));
            buildTest(FilterRedisBuilder.Build <string>(conn, "BuildTest", 10000, 0.01));
            buildTest(FilterRedisBuilder.Build <string>(conn, "BuildTest", 10000, 0.01, hashFun));
            buildTest(FilterRedisBuilder.Build <string>(conn, "BuildTest", 10000, 0.01, HashMethod.Adler32));

            buildTest(FilterRedisBuilder.Build <string>(operate, "BuildTest", 10000));
            buildTest(FilterRedisBuilder.Build <string>(operate, "BuildTest", 10000, hashFun));
            buildTest(FilterRedisBuilder.Build <string>(operate, "BuildTest", 10000, HashMethod.Adler32));
            buildTest(FilterRedisBuilder.Build <string>(operate, "BuildTest", 10000, 0.01));
            buildTest(FilterRedisBuilder.Build <string>(operate, "BuildTest", 10000, 0.01, hashFun));
            buildTest(FilterRedisBuilder.Build <string>(operate, "BuildTest", 10000, 0.01, HashMethod.Adler32));


            conn.Dispose();
        }
        public async Task BuildTestAsync()
        {
            var hashFun = new HashAlgorithms.HashCryptoSHA256();
            var config  = ConfigurationOptions.Parse("localhost");
            var conn    = ConnectionMultiplexer.Connect(config);
            var operate = new RedisBitOperate(conn);

            await buildTestAsync(FilterRedisBuilder.Build(config, "BuildTest", 10000));
            await buildTestAsync(FilterRedisBuilder.Build(config, "BuildTest", 10000, hashFun));
            await buildTestAsync(FilterRedisBuilder.Build(config, "BuildTest", 10000, HashMethod.Adler32));
            await buildTestAsync(FilterRedisBuilder.Build(config, "BuildTest", 10000, 0.01));
            await buildTestAsync(FilterRedisBuilder.Build(config, "BuildTest", 10000, 0.01, hashFun));
            await buildTestAsync(FilterRedisBuilder.Build(config, "BuildTest", 10000, 0.01, HashMethod.Adler32));

            await buildTestAsync(FilterRedisBuilder.Build("localhost", "BuildTest", 10000));
            await buildTestAsync(FilterRedisBuilder.Build("localhost", "BuildTest", 10000, hashFun));
            await buildTestAsync(FilterRedisBuilder.Build("localhost", "BuildTest", 10000, HashMethod.Adler32));
            await buildTestAsync(FilterRedisBuilder.Build("localhost", "BuildTest", 10000, 0.01));
            await buildTestAsync(FilterRedisBuilder.Build("localhost", "BuildTest", 10000, 0.01, hashFun));
            await buildTestAsync(FilterRedisBuilder.Build("localhost", "BuildTest", 10000, 0.01, HashMethod.Adler32));

            await buildTestAsync(FilterRedisBuilder.Build(conn, "BuildTest", 10000));
            await buildTestAsync(FilterRedisBuilder.Build(conn, "BuildTest", 10000, hashFun));
            await buildTestAsync(FilterRedisBuilder.Build(conn, "BuildTest", 10000, HashMethod.Adler32));
            await buildTestAsync(FilterRedisBuilder.Build(conn, "BuildTest", 10000, 0.01));
            await buildTestAsync(FilterRedisBuilder.Build(conn, "BuildTest", 10000, 0.01, hashFun));
            await buildTestAsync(FilterRedisBuilder.Build(conn, "BuildTest", 10000, 0.01, HashMethod.Adler32));

            await buildTestAsync(FilterRedisBuilder.Build(operate, "BuildTest", 10000));
            await buildTestAsync(FilterRedisBuilder.Build(operate, "BuildTest", 10000, hashFun));
            await buildTestAsync(FilterRedisBuilder.Build(operate, "BuildTest", 10000, HashMethod.Adler32));
            await buildTestAsync(FilterRedisBuilder.Build(operate, "BuildTest", 10000, 0.01));
            await buildTestAsync(FilterRedisBuilder.Build(operate, "BuildTest", 10000, 0.01, hashFun));
            await buildTestAsync(FilterRedisBuilder.Build(operate, "BuildTest", 10000, 0.01, HashMethod.Adler32));


            conn.Dispose();
        }
Example #10
0
        public async Task Performance()
        {
            var bf = FilterRedisBuilder.Build("localhost", "bftest", 100000, 0.01);

            var items = new List <string>();

            var count = 50;

            var rndNum = new Random(Guid.NewGuid().GetHashCode());

            for (int i = 0; i < count; i++)
            {
                items.Add(Helper.GenerateString(rndNum.Next(5, 30)));
            }

            await bf.AddAsync(items);

            var sw = Stopwatch.StartNew();

            await bf.ContainsAsync(items);

            Console.WriteLine(sw.Elapsed);
        }
        public void IntTest()
        {
            var config = ConfigurationOptions.Parse("localhost");

            var bf = FilterRedisBuilder.Build <int>(config, "NormalTest", 10000, 0.01);

            var len   = 10;
            var array = new int[len];

            for (int i = 0; i < len; i++)
            {
                array[i] = i;
            }

            Assert.All(bf.Add(array), r => Assert.True(r));
            Assert.All(bf.Contains(array), r => Assert.True(r));

            Assert.True(bf.All(array));

            bf.Clear();

            Assert.All(bf.Contains(array), r => Assert.False(r));
            Assert.False(bf.All(array));
        }
        public async Task IntTestAsync()
        {
            var config = ConfigurationOptions.Parse("localhost");

            var bf = FilterRedisBuilder.Build(config, "IntTestAsync", 10000, 0.01);

            var len   = 10;
            var array = new int[len];

            for (int i = 0; i < len; i++)
            {
                array[i] = i;
            }

            Assert.All(await bf.AddAsync(array), r => Assert.True(r));
            Assert.All(await bf.ContainsAsync(array), r => Assert.True(r));

            Assert.True(await bf.AllAsync(array));

            await bf.ClearAsync();

            Assert.All(await bf.ContainsAsync(array), r => Assert.False(r));
            Assert.False(await bf.AllAsync(array));
        }