Originally posted on: http://geekswithblogs.net/shaunxu/archive/2013/07/01/upload-file-to-windows-azure-blob-in-chunks-through-asp.net.aspxMany people are using Windows Azure Blob Storage
to store their data in
the cloud. Blob storage provides 99.9% availability with easy-to-use API through .NET SDK and HTTP REST. For example, we can store JavaScript files, images, documents in blob storage when we are building an ASP.NET web application on a Web Role in Windows Azure. Or we can store our VHD files in blob and mount it as a hard drive in our cloud service. If you are familiar with Windows Azure, you should know that there are two kinds of blob: page blob and block blob.
The page blob is optimized for random read and write, which is very useful when you need
to store VHD files.
The block blob is optimized for sequential/chunk read and write, which has more common usage. Since we can upload block blob in blocks through BlockBlob.PutBlock, and them commit them as a whole blob with invoking
the BlockBlob.PutBlockList, it is very powerful
to upload large files, as we can upload blocks in parallel, and provide pause-resume feature. There are many documents, articles and blog posts described on how
to upload a block blob. Most of them are focus on
the server side, which means when you had received a big file, stream or binaries, how
to upload them into blob storage in blocks through .NET SDK. But
the problem is, how can we upload these large files from client side, for example, a browser. This questioned
to me when I was working with a Chinese customer
to help them build a network disk production on top of azure.
The end users upload their files from
the web portal, and then
the files will be stored in blob storage from
the Web Role. My goal is
to find
the best way
to transform
the file from client (end user’s machine)
to the server (Web Role) through browser. In this post I will demonstrate and describe what I had done,
to upload large file in chunks with high speed, and save them as blocks into Windows Azure Blob Storage. Traditional Upload, Works with Limitation
The simplest way
to implement this requirement is
to create a web page with a form that contains a file input element and a submit button. 1: @using (Html.BeginForm("About", "Index", FormMethod.Post, new { enctype = "multipart/form-data" }))
2: {
3: <input type="file" name="file" />
4: <input type="submit" value="upload" />
5: }
And then in
the backend controller, we retrieve
the whole content of this file and upload it in
to the blob storage through .NET SDK. We can split
the file in blocks and upload them in parallel and commit.
The code had been well blogged in
the community.
1: [HttpPost]
2: public ActionResult About(HttpPostedFileBase file)
3: {
4: var container = _client.GetContainerReference("test");
5: container.CreateIfNotExists();
6: var blob = container.GetBlockBlobReference(file.FileName);
7: var blockDataList = new Dictionary<string, byte[]>();
8: using (var stream = file.InputStream)
9: {
10: var blockSizeInKB = 1024;
11: var offset = 0;
12: var index = 0;
13: while (offset < stream.Length)
14: {
15: var readLength = Math.Min(1024 * blockSizeInKB, (int)stream.Length - offset);
16: var blockData = new byte[readLength];
17: offset += stream.Read(blockData, 0, readLength);
18: blockDataList.Add(Convert.ToBase64String(BitConverter.GetBytes(index)), blockData);
19:
20: index++;
21: }
22: }
23:
24: Parallel.ForEach(blockDataList, (bi) =>
25: {
26: blob.PutBlock(bi.Key, new MemoryStream(bi.Value), null);
27: });
28: blob.PutBlockList(blockDataList.Select(b => b.Key).ToArray());
29:
30: return RedirectToAction("About");
31: }
This works perfect if we selected an image, a music or a small video
to upload. But if I selected a large file, let’s say a 6GB HD-movie, after upload for about few minutes
the page will be shown as below and
the upload will be terminated.
In ASP.NET there is a limitation of request length and
the maximized request length is defined in
the web.config file. It’s a number which less than about 4GB. So if we want
to upload a really big file, we cannot simply implement in this way. Also, in Windows Azure, a cloud service network load balancer will terminate
the connection if exceed
the timeout period. From my test
the timeout looks like 2 - 3 minutes. Hence, when we need
to upload a large file we cannot just use
the basic HTML elements.
Besides
the limitation mentioned above,
the simple HTML file upload cannot provide rich upload experience such as chunk upload, pause and pause-resume. So we need
to find a better way
to upload large file from
the client
to the server.
Upload in Chunks through HTML5 and JavaScript
In order
to break those limitation mentioned above we will try
to upload
the large file in chunks. This takes some benefit
to us such as
- No request size limitation: Since we upload in chunks, we can define
the request size for each chunks regardless how big
the entire file is.
- No timeout problem:
The size of chunks are controlled by us, which means we should be able
to make sure request for each chunk upload will not exceed
the timeout period of both ASP.NET and Windows Azure load balancer.
It was a big challenge
to upload big file in chunks until we have HTML5. There are some new features and improvements introduced in HTML5 and we will use them
to implement our solution.
In HTML5,
the File interface had been improved with a new method called “slice”. It can be used
to read part of
the file by specifying
the start byte index and
the end byte index. For example if
the entire file was 1024 bytes, file.slice(512, 768) will read
the part of this file from
the 512nd byte
to 768th byte, and return a new object of interface called "Blob”, which you can treat as an array of bytes.
In fact, a Blob object represents a file-like object of immutable, raw data.
The File interface is based on Blob, inheriting blob functionality and expanding it
to support files on
the user's system. For more information about
the Blob please refer here.
File and Blob is very useful
to implement
the chunk upload. We will use File interface
to represent
the file
the user selected from
the browser and then use File.slice
to read
the file in chunks in
the size we wanted. For example, if we wanted
to upload a 10MB file with 512KB chunks, then we can read it in 512KB blobs by using File.slice in a loop.
Assuming we have a web page as below. User can select a file, an input box
to specify
the block size in KB and a button
to start upload.
1: <div>
2: <input type="file" id="upload_files" name="files[]" /><br />
3: Block Size: <input type="number" id="block_size" value="512" name="block_size" />KB<br />
4: <input type="button" id="upload_button_blob" name="upload" value="upload (blob)" />
5: </div>
Then we can have
the JavaScript function
to upload
the file in chunks when user clicked
the button.
1: <script type="text/javascript"> 1: 2: $(function () { 3: $("#upload_button_blob").click(function () { 4: }); 5: });</script>
Firstly we need
to ensure
the client browser supports
the interfaces we are going
to use. Just try
to invoke
the File, Blob and FormData from
the “window” object. If any of them is “undefined”
the condition result will be “false” which means your browser doesn’t support these premium feature and it’s time for you
to get your browser updated.
FormData is another new feature we are going
to use in
the future. It could generate a temporary form for us. We will use this interface
to create a form with chunk and associated metadata when invoked
the service through ajax.
1: $("#upload_button_blob").click(function () {
2: // assert
the browser support html5
3: if (window.File && window.Blob && window.FormData) {
4: alert("Your brwoser is awesome, let's rock!");
5: }
6: else {
7: alert("Oh man plz update
to a modern browser before try is cool stuff out.");
8: return;
9: }
10: });
Each browser supports these interfaces by their own implementation and currently
the Blob, File and File.slice are supported by Chrome 21, FireFox 13, IE 10, Opera 12 and Safari 5.1 or higher.
After that we worked on
the files
the user selected one by one since in HTML5, user can select multiple files in one file input box.
1: var files = $("#upload_files")[0].files;
2: for (var i = 0; i < files.length; i++) {
3: var file = files[i];
4: var fileSize = file.size;
5: var fileName = file.name;
6: }
Next, we calculated
the start index and end index for each chunks based on
the size
the user specified from
the browser. We put them into an array with
the file name and
the index, which will be used when we upload chunks into Windows Azure Blob Storage as blocks since we need
to specify
the target blob name and
the block index.
At
the same time we will store
the list of all indexes into another variant which will be used
to commit blocks into blob in Azure Storage once all chunks had been uploaded successfully.
1: $("#upload_button_blob").click(function () {
2: // assert
the browser support html5
3: ... ...
4: // start
to upload each files in chunks
5: var files = $("#upload_files")[0].files;
6: for (var i = 0; i < files.length; i++) {
7: var file = files[i];
8: var fileSize = file.size;
9: var fileName = file.name;
10:
11: // calculate
the start and end byte index for each blocks(chunks)
12: // with
the index, file name and index list for
future using
13: var blockSizeInKB = $("#block_size").val();
14: var blockSize = blockSizeInKB * 1024;
15: var blocks = [];
16: var offset = 0;
17: var index = 0;
18: var list = "";
19: while (offset < fileSize) {
20: var start = offset;
21: var end = Math.min(offset + blockSize, fileSize);
22:
23: blocks.push({
24: name: fileName,
25: index: index,
26: start: start,
27: end: end
28: });
29: list += index + ",";
30:
31: offset = end;
32: index++;
33: }
34: }
35: });
Now we have all chunks’ information ready.
The next step should be upload them one by one
to the server side, and at
the server side when received a chunk it will upload as a block into Blob Storage, and finally commit them with
the index list through BlockBlobClient.PutBlockList. But since all these invokes are ajax calling, which means not synchronized call. So we need
to introduce a new JavaScript library
to help us coordinate
the asynchronize operation, which named “async.js”.
You can download this JavaScript library here, and you can find
the document here.
I will not explain this library too much in this post. We will put all procedures we want
to execute as a function array, and pass into
the proper function defined in async.js
to let it help us
to control
the execution sequence, in series or in parallel. Hence we will define an array and put
the function for chunk upload into this array.
1: $("#upload_button_blob").click(function () {
2: // assert
the browser support html5
3: ... ...
4:
5: // start
to upload each files in chunks
6: var files = $("#upload_files")[0].files;
7: for (var i = 0; i < files.length; i++) {
8: var file = files[i];
9: var fileSize = file.size;
10: var fileName = file.name;
11: // calculate
the start and end byte index for each blocks(chunks)
12: // with
the index, file name and index list for
future using
13: ... ...
14:
15: // define
the function array and push all chunk upload operation into this array
16: blocks.forEach(function (block) {
17: putBlocks.push(function (callback) {
18: });
19: });
20: }
21: });
22: });
As you can see, I used File.slice method
to read each chunks based on
the start and end byte index we calculated previously, and constructed a temporary HTML form with
the file name, chunk index and chunk data through another new feature in HTML5 named FormData. Then post this form
to the backend server through jQuery.ajax. This is
the key part of our solution.
1: $("#upload_button_blob").click(function () {
2: // assert
the browser support html5
3: ... ...
4: // start
to upload each files in chunks
5: var files = $("#upload_files")[0].files;
6: for (var i = 0; i < files.length; i++) {
7: var file = files[i];
8: var fileSize = file.size;
9: var fileName = file.name;
10: // calculate
the start and end byte index for each blocks(chunks)
11: // with
the index, file name and index list for
future using
12: ... ...
13: // define
the function array and push all chunk upload operation into this array
14: blocks.forEach(function (block) {
15: putBlocks.push(function (callback) {
16: // load blob based on
the start and end index for each chunks
17: var blob = file.slice(block.start, block.end);
18: // put
the file name, index and blob into a temporary from
19: var fd = new FormData();
20: fd.append("name", block.name);
21: fd.append("index", block.index);
22: fd.append("file", blob);
23: // post
the form
to backend service (asp.net mvc controller action)
24: $.ajax({
25: url: "/Home/UploadInFormData",
26: data: fd,
27: processData: false,
28: contentType: "multipart/form-data",
29: type: "POST",
30: success: function (result) {
31: if (!result.success) {
32: alert(result.error);
33: }
34: callback(null, block.index);
35: }
36: });
37: });
38: });
39: }
40: });
Then we will invoke these functions one by one by using
the async.js. And once all functions had been executed successfully I invoked another ajax call
to the backend service
to commit all these chunks (blocks) as
the blob in Windows Azure Storage.
1: $("#upload_button_blob").click(function () {
2: // assert
the browser support html5
3: ... ...
4: // start
to upload each files in chunks
5: var files = $("#upload_files")[0].files;
6: for (var i = 0; i < files.length; i++) {
7: var file = files[i];
8: var fileSize = file.size;
9: var fileName = file.name;
10: // calculate
the start and end byte index for each blocks(chunks)
11: // with
the index, file name and index list for
future using
12: ... ...
13: // define
the function array and push all chunk upload operation into this array
14: ... ...
15: // invoke
the functions one by one
16: // then invoke
the commit ajax call
to put blocks into blob in azure storage
17: async.series(putBlocks, function (error, result) {
18: var data = {
19: name: fileName,
20: list: list
21: };
22: $.post("/Home/Commit", data, function (result) {
23: if (!result.success) {
24: alert(result.error);
25: }
26: else {
27: alert("done!");
28: }
29: });
30: });
31: }
32: });
That’s all in
the client side.
The outline of our logic would be
- Calculate
the start and end byte index for each chunks based on
the block size.
- Defined
the functions of reading
the chunk form file and upload
the content
to the backend service through ajax.
- Execute
the functions defined in previous step with “async.js”.
- Commit
the chunks by invoking
the backend service in Windows Azure Storage finally.
Save Chunks as Blocks into Blob Storage
In above we finished
the client size JavaScript code. It uploaded
the file in chunks
to the backend service which we are going
to implement in this step. We will use ASP.NET MVC as our backend service, and it will receive
the chunks, upload into Windows Azure Bob Storage in blocks, then finally commit as one blob.
As in
the client side we uploaded chunks by invoking
the ajax call
to the URL "/Home/UploadInFormData", I created a new action under
the Index controller and it only accepts HTTP POST request.
1: [HttpPost]
2: public JsonResult UploadInFormData()
3: {
4: var error = string.Empty;
5: try
6: {
7: }
8: catch (Exception e)
9: {
10: error = e.ToString();
11: }
12:
13: return new JsonResult()
14: {
15: Data = new
16: {
17: success = string.IsNullOrWhiteSpace(error),
18: error = error
19: }
20: };
21: }
Then I retrieved
the file name, index and
the chunk content from
the Request.Form object, which was passed from our client side. And then, used
the Windows Azure SDK
to create a blob container (in this case we will use
the container named “test”.) and create a blob reference with
the blob name (same as
the file name). Then uploaded
the chunk as a block of this blob with
the index, since in Blob Storage each block must have an index (ID) associated with so that finally we can put all blocks as one blob by specifying their block ID list.
1: [HttpPost]
2: public JsonResult UploadInFormData()
3: {
4: var error = string.Empty;
5: try
6: {
7: var name = Request.Form["name"];
8: var index = int.Parse(Request.Form["index"]);
9: var file = Request.Files[0];
10: var id = Convert.ToBase64String(BitConverter.GetBytes(index));
11:
12: var container = _client.GetContainerReference("test");
13: container.CreateIfNotExists();
14: var blob = container.GetBlockBlobReference(name);
15: blob.PutBlock(id, file.InputStream, null);
16: }
17: catch (Exception e)
18: {
19: error = e.ToString();
20: }
21:
22: return new JsonResult()
23: {
24: Data = new
25: {
26: success = string.IsNullOrWhiteSpace(error),
27: error = error
28: }
29: };
30: }
Next, I created another action
to commit
the blocks into blob once all chunks had been uploaded. Similarly, I retrieved
the blob name from
the Request.Form. I also retrieved
the chunks ID list, which is
the block ID list from
the Request.Form in a string format, split them as a list, then invoked
the BlockBlob.PutBlockList method. After that our blob will be shown in
the container and ready
to be download.
1: [HttpPost]
2: public JsonResult Commit()
3: {
4: var error = string.Empty;
5: try
6: {
7: var name = Request.Form["name"];
8: var list = Request.Form["list"];
9: var ids = list
10: .Split(',')
11: .Where(id => !string.IsNullOrWhiteSpace(id))
12: .Select(id => Convert.ToBase64String(BitConverter.GetBytes(int.Parse(id))))
13: .ToArray();
14:
15: var container = _client.GetContainerReference("test");
16: container.CreateIfNotExists();
17: var blob = container.GetBlockBlobReference(name);
18: blob.PutBlockList(ids);
19: }
20: catch (Exception e)
21: {
22: error = e.ToString();
23: }
24:
25: return new JsonResult()
26: {
27: Data = new
28: {
29: success = string.IsNullOrWhiteSpace(error),
30: error = error
31: }
32: };
33: }
Now we finished all code we need.
The whole process of uploading would be like this below.
Below is
the full client side JavaScript code.
1: <script type="text/javascript" src="~/Scripts/async.js"></script>
2: <script type="text/javascript">
3: $(function () {
4: $("#upload_button_blob").click(function () {
5: // assert
the browser support html5
6: if (window.File && window.Blob && window.FormData) {
7: alert("Your brwoser is awesome, let's rock!");
8: }
9: else {
10: alert("Oh man plz update
to a modern browser before try is cool stuff out.");
11: return;
12: }
13:
14: // start
to upload each files in chunks
15: var files = $("#upload_files")[0].files;
16: for (var i = 0; i < files.length; i++) {
17: var file = files[i];
18: var fileSize = file.size;
19: var fileName = file.name;
20:
21: // calculate
the start and end byte index for each blocks(chunks)
22: // with
the index, file name and index list for
future using
23: var blockSizeInKB = $("#block_size").val();
24: var blockSize = blockSizeInKB * 1024;
25: var blocks = [];
26: var offset = 0;
27: var index = 0;
28: var list = "";
29: while (offset < fileSize) {
30: var start = offset;
31: var end = Math.min(offset + blockSize, fileSize);
32:
33: blocks.push({
34: name: fileName,
35: index: index,
36: start: start,
37: end: end
38: });
39: list += index + ",";
40:
41: offset = end;
42: index++;
43: }
44:
45: // define
the function array and push all chunk upload operation into this array
46: var putBlocks = [];
47: blocks.forEach(function (block) {
48: putBlocks.push(function (callback) {
49: // load blob based on
the start and end index for each chunks
50: var blob = file.slice(block.start, block.end);
51: // put
the file name, index and blob into a temporary from
52: var fd = new FormData();
53: fd.append("name", block.name);
54: fd.append("index", block.index);
55: fd.append("file", blob);
56: // post
the form
to backend service (asp.net mvc controller action)
57: $.ajax({
58: url: "/Home/UploadInFormData",
59: data: fd,
60: processData: false,
61: contentType: "multipart/form-data",
62: type: "POST",
63: success: function (result) {
64: if (!result.success) {
65: alert(result.error);
66: }
67: callback(null, block.index);
68: }
69: });
70: });
71: });
72:
73: // invoke
the functions one by one
74: // then invoke
the commit ajax call
to put blocks into blob in azure storage
75: async.series(putBlocks, function (error, result) {
76: var data = {
77: name: fileName,
78: list: list
79: };
80: $.post("/Home/Commit", data, function (result) {
81: if (!result.success) {
82: alert(result.error);
83: }
84: else {
85: alert("done!");
86: }
87: });
88: });
89: }
90: });
91: });
92: </script>
And below is
the full ASP.NET MVC controller code.
1: public class HomeController : Controller
2: {
3: private CloudStorageAccount _account;
4: private CloudBlobClient _client;
5:
6: public HomeController()
7: : base()
8: {
9: _account = CloudStorageAccount.Parse(CloudConfigurationManager.GetSetting("DataConnectionString"));
10: _client = _account.CreateCloudBlobClient();
11: }
12:
13: public ActionResult Index()
14: {
15: ViewBag.Message = "Modify this template
to jump-start your ASP.NET MVC application.";
16:
17: return View();
18: }
19:
20: [HttpPost]
21: public JsonResult UploadInFormData()
22: {
23: var error = string.Empty;
24: try
25: {
26: var name = Request.Form["name"];
27: var index = int.Parse(Request.Form["index"]);
28: var file = Request.Files[0];
29: var id = Convert.ToBase64String(BitConverter.GetBytes(index));
30:
31: var container = _client.GetContainerReference("test");
32: container.CreateIfNotExists();
33: var blob = container.GetBlockBlobReference(name);
34: blob.PutBlock(id, file.InputStream, null);
35: }
36: catch (Exception e)
37: {
38: error = e.ToString();
39: }
40:
41: return new JsonResult()
42: {
43: Data = new
44: {
45: success = string.IsNullOrWhiteSpace(error),
46: error = error
47: }
48: };
49: }
50:
51: [HttpPost]
52: public JsonResult Commit()
53: {
54: var error = string.Empty;
55: try
56: {
57: var name = Request.Form["name"];
58: var list = Request.Form["list"];
59: var ids = list
60: .Split(',')
61: .Where(id => !string.IsNullOrWhiteSpace(id))
62: .Select(id => Convert.ToBase64String(BitConverter.GetBytes(int.Parse(id))))
63: .ToArray();
64:
65: var container = _client.GetContainerReference("test");
66: container.CreateIfNotExists();
67: var blob = container.GetBlockBlobReference(name);
68: blob.PutBlockList(ids);
69: }
70: catch (Exception e)
71: {
72: error = e.ToString();
73: }
74:
75: return new JsonResult()
76: {
77: Data = new
78: {
79: success = string.IsNullOrWhiteSpace(error),
80: error = error
81: }
82: };
83: }
84: }
And if we selected a file from
the browser we will see our application will upload chunks in
the size we specified
to the server through ajax call in background, and then commit all chunks in one blob.
Then we can find
the blob in our Windows Azure Blob Storage.
Optimized by Parallel Upload
In previous example we just uploaded our file in chunks. This solved
the problem that ASP.NET MVC request content size limitation as well as
the Windows Azure load balancer timeout. But it might introduce
the performance problem since we uploaded chunks in sequence. In order
to improve
the upload performance we could modify our client side code a bit
to make
the upload operation invoked in parallel.
The good news is that, “async.js” library provides
the parallel execution function. If you remembered
the code we invoke
the service
to upload chunks, it utilized “async.series” which means all functions will be executed in sequence. Now we will change this code
to “async.parallel”. This will invoke all functions in parallel.
1: $("#upload_button_blob").click(function () {
2: // assert
the browser support html5
3: ... ...
4: // start
to upload each files in chunks
5: var files = $("#upload_files")[0].files;
6: for (var i = 0; i < files.length; i++) {
7: var file = files[i];
8: var fileSize = file.size;
9: var fileName = file.name;
10: // calculate
the start and end byte index for each blocks(chunks)
11: // with
the index, file name and index list for
future using
12: ... ...
13: // define
the function array and push all chunk upload operation into this array
14: ... ...
15: // invoke
the functions one by one
16: // then invoke
the commit ajax call
to put blocks into blob in azure storage
17: async.parallel(putBlocks, function (error, result) {
18: var data = {
19: name: fileName,
20: list: list
21: };
22: $.post("/Home/Commit", data, function (result) {
23: if (!result.success) {
24: alert(result.error);
25: }
26: else {
27: alert("done!");
28: }
29: });
30: });
31: }
32: });
In this way all chunks will be uploaded
to the server side at
the same time
to maximize
the bandwidth usage.
This should work if
the file was not very large and
the chunk size was not very small. But for large file this might introduce another problem that too many ajax calls are sent
to the server at
the same time. So
the best solution should be, upload
the chunks in parallel with maximum concurrency limitation.
The code below specified
the concurrency limitation
to 4, which means at
the most only 4 ajax calls could be invoked at
the same time.
1: $("#upload_button_blob").click(function () {
2: // assert
the browser support html5
3: ... ...
4: // start
to upload each files in chunks
5: var files = $("#upload_files")[0].files;
6: for (var i = 0; i < files.length; i++) {
7: var file = files[i];
8: var fileSize = file.size;
9: var fileName = file.name;
10: // calculate
the start and end byte index for each blocks(chunks)
11: // with
the index, file name and index list for
future using
12: ... ...
13: // define
the function array and push all chunk upload operation into this array
14: ... ...
15: // invoke
the functions one by one
16: // then invoke
the commit ajax call
to put blocks into blob in azure storage
17: async.parallelLimit(putBlocks, 4, function (error, result) {
18: var data = {
19: name: fileName,
20: list: list
21: };
22: $.post("/Home/Commit", data, function (result) {
23: if (!result.success) {
24: alert(result.error);
25: }
26: else {
27: alert("done!");
28: }
29: });
30: });
31: }
32: });
Summary
In this post we discussed how
to upload files in chunks
to the backend service and then upload them into Windows Azure Blob Storage in blocks. We focused on
the frontend side and leverage three new feature introduced in HTML 5 which are
- File.slice: Read part of
the file by specifying
the start and end byte index.
- Blob: File-like interface which contains
the part of
the file content.
- FormData: Temporary form element that we can pass
the chunk alone with some metadata
to the backend service.
Then we discussed
the performance consideration of chunk uploading. Sequence upload cannot provide maximized upload speed, but
the unlimited parallel upload might crash
the browser and server if too many chunks. So we finally came up with
the solution
to upload chunks in parallel with
the concurrency limitation.
We also demonstrated how
to utilize “async.js” JavaScript library
to help us control
the asynchronize call and
the parallel limitation.
Regarding
the chunk size and
the parallel limitation value there is no “best” value. You need
to test vary composition and find out
the best one for your particular scenario. It depends on
the local bandwidth, client machine cores and
the server side (Windows Azure Cloud Service Virtual Machine) cores, memory and bandwidth.
Below is one of my performance test result.
The client machine was Windows 8 IE 10 with 4 cores. I was using Microsoft Cooperation Network.
The web site was hosted on Windows Azure China North data center (in Beijing) with one small web role (1.7GB 1 core CPU, 1.75GB memory with 100Mbps bandwidth).
The test cases were
- Chunk size: 512KB, 1MB, 2MB, 4MB.
- Upload Mode: Sequence, parallel (unlimited), parallel with limit (4 threads, 8 threads).
- Chunk Format: base64 string, binaries.
- Target file: 100MB.
- Each case was tested 3 times.
Below is
the test result chart.
Some thoughts, but not guidance or best practice:
- Parallel gets better performance than series.
- No significant performance improvement between parallel 4 threads and 8 threads.
- Transform with binaries provides better performance than base64.
- In all cases, chunk size in 1MB - 2MB gets better performance.
Hope this helps,
Shaun
All documents and related graphics, codes are provided "AS IS" without warranty of any kind.
Copyright © Shaun Ziyan Xu. This work is licensed under
the Creative Commons License.
