Update setAwkTimer and base64 (hyperledger-iroha#221)

- base64 implementation updated
- setAwkTimer updated, now it does not create threads with each call
- hash benchmark added

benchmark/crypto/CMakeLists.txt

@@ -2,10 +2,20 @@ include_directories(
   ${PROJECT_SOURCE_DIR}/core
 )
 
+# hash benchmark
 add_executable(hash_benchmark
   hash.cpp
 )
 target_link_libraries(hash_benchmark
   benchmark
   hash
 )
+
+
+# base64 benchmark
+add_executable(base64_benchmark
+  base64.cpp
+)
+target_link_libraries(base64_benchmark
+  benchmark
+)

benchmark/crypto/base64.cpp

@@ -0,0 +1,177 @@
+/**
+ * Copyright Soramitsu Co., Ltd. 2016 All Rights Reserved.
+ * http://soramitsu.co.jp
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <benchmark/benchmark.h>
+#include <algorithm>
+#include <vector>
+#include <string>
+#include <infra/crypto/base64.cpp>
+
+namespace v1 {
+    /* 
+    base64.cpp and base64.h
+
+    Copyright (C) 2004-2008 René Nyffenegger
+
+    This source code is provided 'as-is', without any express or implied
+    warranty. In no event will the author be held liable for any damages
+    arising from the use of this software.
+
+    Permission is granted to anyone to use this software for any purpose,
+    including commercial applications, and to alter it and redistribute it
+    freely, subject to the following restrictions:
+
+    1. The origin of this source code must not be misrepresented; you must not
+        claim that you wrote the original source code. If you use this source code
+        in a product, an acknowledgment in the product documentation would be
+        appreciated but is not required.
+
+    2. Altered source versions must be plainly marked as such, and must not be
+        misrepresented as being the original source code.
+
+    3. This notice may not be removed or altered from any source distribution.
+
+    René Nyffenegger [email protected]
+
+  */
+
+  static const std::string base64_chars = 
+              "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+              "abcdefghijklmnopqrstuvwxyz"
+              "0123456789+/";
+
+
+  static inline bool is_base64(unsigned char c) {
+    return (isalnum(c) || (c == '+') || (c == '/'));
+  }
+
+  std::string base64_encode(unsigned char const* bytes_to_encode, unsigned int in_len) {
+    std::string ret;
+    int i = 0;
+    int j = 0;
+    unsigned char char_array_3[3];
+    unsigned char char_array_4[4];
+
+    while (in_len--) {
+      char_array_3[i++] = *(bytes_to_encode++);
+      if (i == 3) {
+        char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
+        char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
+        char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
+        char_array_4[3] = char_array_3[2] & 0x3f;
+
+        for(i = 0; (i <4) ; i++)
+          ret += base64_chars[char_array_4[i]];
+        i = 0;
+      }
+    }
+
+    if (i)
+    {
+      for(j = i; j < 3; j++)
+        char_array_3[j] = '\0';
+
+      char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
+      char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
+      char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
+      char_array_4[3] = char_array_3[2] & 0x3f;
+
+      for (j = 0; (j < i + 1); j++)
+        ret += base64_chars[char_array_4[j]];
+
+      while((i++ < 3))
+        ret += '=';
+
+    }
+
+    return ret;
+
+  }
+
+  std::string base64_decode(std::string const& encoded_string) {
+    int in_len = encoded_string.size();
+    int i = 0;
+    int j = 0;
+    int in_ = 0;
+    unsigned char char_array_4[4], char_array_3[3];
+    std::string ret;
+
+    while (in_len-- && ( encoded_string[in_] != '=') && is_base64(encoded_string[in_])) {
+      char_array_4[i++] = encoded_string[in_]; in_++;
+      if (i ==4) {
+        for (i = 0; i <4; i++)
+          char_array_4[i] = base64_chars.find(char_array_4[i]);
+
+        char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
+        char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
+        char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];
+
+        for (i = 0; (i < 3); i++)
+          ret += char_array_3[i];
+        i = 0;
+      }
+    }
+
+    if (i) {
+      for (j = i; j <4; j++)
+        char_array_4[j] = 0;
+
+      for (j = 0; j <4; j++)
+        char_array_4[j] = base64_chars.find(char_array_4[j]);
+
+      char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
+      char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
+      char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];
+
+      for (j = 0; (j < i - 1); j++) ret += char_array_3[j];
+    }
+
+    return ret;
+  }
+} // namespace v1
+
+
+
+static std::vector<unsigned char> generate_sequence(size_t size){
+  std::vector<unsigned char> v(size);
+  unsigned int seed = 0;
+  for(int i=0; i<v[i]; i++){
+    v[i] = rand_r(&seed) & 0xFF;
+  }
+  return v;
+}
+
+#define MIN_SIZE (1 << 5)
+#define MAX_SIZE (1 << 10)
+
+static const std::vector<unsigned char> data = generate_sequence(MAX_SIZE);
+
+static void base64_v1_encode(benchmark::State& state) {
+  while (state.KeepRunning()) {
+    v1::base64_encode(data.data(), state.range(0));
+  }
+}
+
+static void base64_iroha_encode(benchmark::State& state) {
+  while (state.KeepRunning()) {
+    base64::vendor::base64_encode(data.data(), state.range(0));
+  }
+}
+
+BENCHMARK(base64_iroha_encode)->Range(MIN_SIZE, MAX_SIZE);
+BENCHMARK(base64_v1_encode)->Range(MIN_SIZE, MAX_SIZE);
+BENCHMARK_MAIN();

core/consensus/sumeragi.cpp

@@ -407,10 +407,12 @@ namespace sumeragi {
     }
 
     void setAwkTimer(int const sleepMillisecs, std::function<void(void)> const action) {
-        std::thread([action, sleepMillisecs]() {
-            std::this_thread::sleep_for(std::chrono::milliseconds(sleepMillisecs));
-            action();
-        }).join();
+    //    std::thread([action, sleepMillisecs]() {
+    //        std::this_thread::sleep_for(std::chrono::milliseconds(sleepMillisecs));
+    //        action();
+    //    }).join();
+        std::this_thread::sleep_for(std::chrono::milliseconds(sleepMillisecs));
+        action();
     }
 
     /**