Add performance test

Microsoft.WindowsAzure.Storage/samples/BlobsPerformanceBenchmark.cpp

@@ -0,0 +1,109 @@
+// -----------------------------------------------------------------------------------------
+// <copyright file="BlobsGettingStarted.cpp" company="Microsoft">
+//    Copyright 2013 Microsoft Corporation
+//
+//    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.
+// </copyright>
+// -----------------------------------------------------------------------------------------
+
+#include "samples_common.h"
+
+#include <thread>
+#include <chrono>
+#include <random>
+#include <algorithm>
+
+#include <was/storage_account.h>
+#include <was/blob.h>
+#include <cpprest/filestream.h>
+#include <cpprest/containerstream.h>
+
+namespace azure { namespace storage { namespace samples {
+
+    SAMPLE(BlobsPerformanceBenchmark, blobs_performance_benchmark)
+    void blobs_performance_benchmark()
+    {
+        try
+        {
+            azure::storage::cloud_storage_account storage_account = azure::storage::cloud_storage_account::parse(storage_connection_string);
+
+            azure::storage::cloud_blob_client blob_client = storage_account.create_cloud_blob_client();
+            azure::storage::cloud_blob_container container = blob_client.get_container_reference(_XPLATSTR("benchmark-container"));
+
+            container.create_if_not_exists();
+
+            const uint64_t blob_size = 1024 * 1024 * 1024;
+            const int parallelism = 20;
+
+            std::vector<uint8_t> buffer;
+            buffer.resize(blob_size);
+
+            std::mt19937_64 rand_engine(std::random_device{}());
+            std::uniform_int_distribution<uint64_t> dist;
+            std::generate(reinterpret_cast<uint64_t*>(buffer.data()), reinterpret_cast<uint64_t*>(buffer.data() + buffer.size()), [&dist, &rand_engine]() { return dist(rand_engine); });
+
+            azure::storage::blob_request_options options;
+            options.set_parallelism_factor(8);
+            options.set_use_transactional_crc64(false);
+            options.set_use_transactional_md5(false);
+            options.set_store_blob_content_md5(false);
+            options.set_stream_write_size_in_bytes(32 * 1024 * 1024);
+
+            std::vector<pplx::task<void>> tasks;
+
+            auto start = std::chrono::steady_clock::now();
+            for (int i = 0; i < parallelism; ++i)
+            {
+                auto blob = container.get_block_blob_reference(_XPLATSTR("blob") + utility::conversions::to_string_t(std::to_string(i)));
+                auto task = blob.upload_from_stream_async(concurrency::streams::container_buffer<std::vector<uint8_t>>(buffer).create_istream(), blob_size, azure::storage::access_condition(), options, azure::storage::operation_context());
+                tasks.emplace_back(std::move(task));
+            }
+            for (auto& t : tasks)
+            {
+                t.get();
+            }
+            auto end = std::chrono::steady_clock::now();
+
+            double elapsed_s = double(std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count()) / 1000;
+            uint64_t data_mb = blob_size * parallelism / 1024 / 1024;
+
+            std::cout << "Uploaded " << data_mb << "MB in " << elapsed_s << " seconds, throughput " << data_mb / elapsed_s << "MBps" << std::endl;
+
+            tasks.clear();
+            start = std::chrono::steady_clock::now();
+            {
+                std::vector<concurrency::streams::container_buffer<std::vector<uint8_t>>> download_buffers;
+                for (int i = 0; i < parallelism; ++i)
+                {
+                    auto blob = container.get_block_blob_reference(_XPLATSTR("blob") + utility::conversions::to_string_t(std::to_string(i)));
+                    download_buffers.emplace_back(concurrency::streams::container_buffer<std::vector<uint8_t>>());
+                    auto task = blob.download_to_stream_async(download_buffers.back().create_ostream(), azure::storage::access_condition(), options, azure::storage::operation_context());
+                    tasks.emplace_back(std::move(task));
+                }
+                for (auto& t : tasks)
+                {
+                    t.get();
+                }
+                end = std::chrono::steady_clock::now();
+            }
+
+            elapsed_s = double(std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count()) / 1000;
+
+            std::cout << "Downloaded " << data_mb << "MB in " << elapsed_s << " seconds, throughput " << data_mb / elapsed_s << "MBps" << std::endl;
+        }
+        catch (const azure::storage::storage_exception& e)
+        {
+            std::cout << e.what() << std::endl;
+        }
+    }
+
+}}}  // namespace azure::storage::samples

Microsoft.WindowsAzure.Storage/samples/CMakeLists.txt

@@ -1,6 +1,7 @@
 if(UNIX)
   set(SOURCES
     BlobsGettingStarted.cpp
+    BlobsPerformanceBenchmark.cpp
     FilesGettingStarted.cpp
     JsonPayloadFormat.cpp
     main.cpp