submodule: use new random APIs of rdsn (#183)

src/redis_protocol/proxy_ut/redis_proxy_test.cpp

@@ -9,6 +9,7 @@
 #include <boost/asio.hpp>
 
 #include <dsn/utility/string_conv.h>
+#include <dsn/utility/rand.h>
 
 #include <gtest/gtest.h>
 #include <rrdb/rrdb.client.h>
@@ -197,17 +198,17 @@ class redis_test_parser : public redis_parser
         // create several requests
         for (entry_index = 0; entry_index < total_requests; ++entry_index) {
             redis_request &ra = reserved_entry[entry_index]->request;
-            ra.length = dsn_random32(1, 20);
+            ra.length = dsn::rand::next_u32(1, 20);
             ra.buffers.resize(ra.length);
             for (unsigned int i = 0; i != ra.length; ++i) {
                 redis_bulk_string &bs = ra.buffers[i];
-                bs.length = dsn_random32(0, 8);
+                bs.length = dsn::rand::next_u32(0, 8);
                 if (bs.length == 0) {
                     bs.length = -1;
                 } else if (bs.length == 1) {
                     bs.length = 0;
                 } else {
-                    bs.length = dsn_random32(1, 256);
+                    bs.length = dsn::rand::next_u32(1, 256);
                     std::shared_ptr<char> raw_buf(new char[bs.length],
                                                   std::default_delete<char[]>());
                     memset(raw_buf.get(), 't', bs.length);
@@ -256,11 +257,11 @@ class redis_test_parser : public redis_parser
         // let's split the messages into different pieces
         {
             entry_index = 0;
-            size_t slice_count = dsn_random32(total_requests, total_body_size);
+            size_t slice_count = dsn::rand::next_u32(total_requests, total_body_size);
             std::vector<int> start_pos;
             start_pos.push_back(0);
             for (unsigned int i = 0; i < slice_count - 1; ++i) {
-                start_pos.push_back(dsn_random32(0, total_body_size - 1));
+                start_pos.push_back(dsn::rand::next_u32(0, total_body_size - 1));
             }
             start_pos.push_back(total_body_size);
             std::sort(start_pos.begin(), start_pos.end());

src/server/pegasus_scan_context.h

@@ -7,6 +7,7 @@
 #include <map>
 #include <rocksdb/db.h>
 #include <dsn/tool_api.h>
+#include <dsn/utility/rand.h>
 #include <rrdb/rrdb_types.h>
 
 #include "base/pegasus_const.h"
@@ -76,7 +77,7 @@ class pegasus_context_cache
         //
         // however, currently the implementation is not 100% correct.
         //
-        _counter = dsn_random64(0, 2L << 31);
+        _counter = dsn::rand::next_u64(0, 2L << 31);
         _counter <<= 32;
     }
 

src/server/pegasus_server_impl.cpp

@@ -2330,7 +2330,7 @@ bool pegasus_server_impl::set_usage_scenario(const std::string &usage_scenario)
             // write_buffer_size = random_nearby(db_opts.write_buffer_size)
             //
             uint64_t buffer_size =
-                dsn_random64(_db_opts.write_buffer_size, _db_opts.write_buffer_size * 2);
+                dsn::rand::next_u64(_db_opts.write_buffer_size, _db_opts.write_buffer_size * 2);
             new_options["write_buffer_size"] = boost::lexical_cast<std::string>(buffer_size);
 
             //

src/server/pegasus_server_impl.h

@@ -227,7 +227,7 @@ class pegasus_server_impl : public ::dsn::apps::rrdb_service
     uint64_t get_random_nearby(uint64_t base_value)
     {
         uint64_t gap = base_value / 4;
-        return dsn_random64(base_value - gap, base_value + gap);
+        return dsn::rand::next_u64(base_value - gap, base_value + gap);
     }
 
     // return true if expired

src/server/test/pegasus_server_write_test.cpp

@@ -41,8 +41,8 @@ class pegasus_server_write_test : public pegasus_server_test_base
                 req.key = key;
                 req.value.assign("value", 0, 5);
 
-                int put_rpc_cnt = dsn_random32(1, 10);
-                int remove_rpc_cnt = dsn_random32(1, 10);
+                int put_rpc_cnt = dsn::rand::next_u32(1, 10);
+                int remove_rpc_cnt = dsn::rand::next_u32(1, 10);
                 int total_rpc_cnt = put_rpc_cnt + remove_rpc_cnt;
                 auto writes = new dsn::message_ex *[total_rpc_cnt];
                 for (int i = 0; i < put_rpc_cnt; i++) {

src/test/function_test/test_recovery.cpp

@@ -12,6 +12,7 @@
 
 #include <dsn/service_api_c.h>
 #include <dsn/dist/replication/replication_ddl_client.h>
+#include <dsn/utility/rand.h>
 
 #include <pegasus/client.h>
 #include <gtest/gtest.h>
@@ -298,7 +299,7 @@ TEST_F(recovery_test, recovery)
     {
         prepare_recovery();
         for (int i = 0; i < default_partitions; ++i) {
-            int replica_id = dsn_random32(1, 3);
+            int replica_id = dsn::rand::next_u32(1, 3);
             delete_replica(replica_id, 2, i);
         }
 

src/test/pressure_test/main.cpp

@@ -9,7 +9,7 @@
 
 #include <dsn/c/api_utilities.h>
 #include <dsn/c/api_layer1.h>
-#include <dsn/utility/utils.h>
+#include <dsn/utility/rand.h>
 #include <dsn/tool-api/async_calls.h>
 
 #include "pegasus/client.h"
@@ -19,9 +19,6 @@ using namespace ::pegasus;
 
 DEFINE_TASK_CODE(LPC_DEFAUT_TASK, TASK_PRIORITY_COMMON, dsn::THREAD_POOL_DEFAULT)
 
-//[min, max], min and max is unsigned
-//  dsn_random64(min, max);  or  dsn_random32(min, max)
-
 static int32_t hashkey_len;
 static int32_t sortkey_len;
 static int32_t value_len;
@@ -45,7 +42,7 @@ std::string fill_string(const std::string &str, int len)
 
 std::string get_hashkey()
 {
-    std::string key = to_string(dsn_random64(0, hashkey_limit));
+    std::string key = to_string(dsn::rand::next_u64(0, hashkey_limit));
     if (key.size() >= hashkey_len) {
         return key;
     } else {
@@ -55,7 +52,7 @@ std::string get_hashkey()
 
 std::string get_sortkey()
 {
-    std::string key = to_string(dsn_random64(0, sortkey_limit));
+    std::string key = to_string(dsn::rand::next_u64(0, sortkey_limit));
     if (key.size() >= sortkey_len) {
         return key;
     } else {