BFC: High-Performance Distributed Big-File Cloud Storage Based On Key-Value Store

IDL - International Digital Library Of
Technology & Research
Volume 1, Issue 5, May 2017 Available at: www.dbpublications.org
International e-Journal For Technology And Research-2017
IDL - International Digital Library 1 | P a g e Copyright@IDL-2017
BFC: High-Performance Distributed Big-File
Cloud Storage Based On Key-Value Store
Nalina H.S1
, Dr. K.Thippeswamy2
1 Student, 2 Professor & HOD
Department of Computer Science Engineering
VTU PG Center Mysore
Abstract: Nowadays, cloud-based storage services
are rapidly growing and becoming an emerging trend
in data storage field. There are many problems when
designing an efficient storage engine for cloud-based
systems with some requirements such as big-file
processing, lightweight meta-data, low latency,
parallel I/O, Deduplication, distributed, high
scalability. Key-value stores played an important role
and showed many advantages when solving those
problems. This paper presents about Big File Cloud
(BFC) with its algorithms and architecture to handle
most of problems in a big-file cloud storage system
based on key value store. It is done by proposing low-
complicated, fixed-size meta-data design, which
supports fast and highly-concurrent, distributed file
I/O, several algorithms for resumable upload,
download and simple data Deduplication method for
static data. This research applied the advantages of
ZDB - an in-house key value store which was
optimized with auto-increment integer keys for solving
big-file storage problems efficiently. The results can
be used for building scalable distributed data cloud
storage that support big-file with size up to several
terabytes.
Keywords: Cloud Storage, Key-Value, NoSQL, Big
File, Distributed Storage
INTRODUCTION
Cloud-based storage services commonly serves
millions of users with storage capacity for each user
can reach to several gigabytes to terabytes of data.
People use cloud storage for the daily demands, for
example backing-up data, sharing file to their friends
via social networks such as Facebook [3], Zing Me
[2]. Users also probably upload data from many
different types of devices such as computer, mobile
phone or tablet. After that, they can download or share
them to others. System load in a cloud storage is
usually really heavy. Thus, to guarantee a good quality
of service for users, the system has to face many
difficult problems and requirements: Serving intensity
data service for a large number of users without bottle-
neck; Storing, retrieving and managing big-files in the
system efficiently; Parallel and resumable uploading
and downloading; Data deduplication to reduce the
waste of storage space caused by storing the same
static data from different users. In traditional file
systems, there are many challenges for service builder
when managing a huge number of bigfile:
How to scale system for the incredible growth of data;
How to distribute data in a large number of nodes;
How to replicate data for load-balancing and fault-
tolerance; How to cache frequently accessed data for
fast I/O, etc. A common method for solving these
problems which is used in many Distributed File
Systems and Cloud Storages is splitting big file to
multiple smaller chunks, storing them on disks or
distributed nodes and then managing them using a

meta-data system [1], [8], [24], [4]. Storing chunks
and meta-data efficiently and designing a lightweight
meta-data are significant problems that cloud storage
providers have to face. After a long time of
investigating, we realized that current cloud storage
services have a complex meta-data system, at least the
size of metadata is linear to the file size for every file.
Therefore, the space complexity of these meta-data
system is O(n) and it is not well scalable for big-file.
In this research, we propose new big-file cloud storage
architecture and a better solution to reduce the space
complexity of meta-data. Key-Value stores have many
advantages for storing data in data-intensity services.
They often outperform traditional relational databases
in the ability of heavy load and large scale systems.
In recent years, key-value stores have an
unprecedented growth in both academic and industrial
field. They have low-latency response time and good
scalability with small and medium key-value pair size.
Current key-value stores are not designed for directly
storing big-values, or big file in our case. We executed
several experiments in which we put whole file-data to
key-value store, the system did not have good
performance as usual for many reasons: firstly, the
latency of put/get operation for big-values is high, thus
it affects other concurrent operations of key-value
store service and multiple parallel accesses to different
value reach limited. Secondly, when the value is big,
there is no more space to cache another objects in
main memory for fast access operations. Finally, it is
difficult to scale-out system when number of users and
data increase. This research is implemented to solve
those problems when storing big-values or big-file
using key-value stores. It brings many advantages of
key-value store in data management to design a cloud-
storage system called Big File Cloud (BFC).
These are our contributions in this research:
– Propose a light-weight meta-data design for big file.
Every file has nearly the same size of meta-data.
BFC has O(1) space complexity of meta-data of a
file, while size of meta-data of a file in Dropbox[1],
HDFS[4] has space complexity of O(n) where n is
size of original file. See Fig 9
– Propose a logical contiguous chunk-id of chunk
collection of files. That make it easier to distribute
data and scale-out the storage system.
– Bring the advantages of key-value store into big-file
data store which is not default supported for big-value.
These contributions are implemented and evaluated in
Big File Cloud (BFC) that serve storage for Zing Me
Users. Disk Image files of VNG’s CSM Boot diskless
system are stored in Big File Cloud.
II. BIG FILE CLOUD ARCHITECTURE
A. Architecture Overview
BFC System includes four layers: Application Layer,
Storage Logical Layer, Object Store Layer and
Persistent Layer.
Each layer contains several coordinated components.
They are shown more details in Fig 2. Application
Layer consists of native software on desktop
computers, mobile devices and web-interface, which
allow user to upload, download and share their own
files. This layer uses API provided by Storage Logical
Layer and applies several algorithms for downloading
and uploading process which are described in
subsections II-F and II-G. Storage Logical Layer
consisted of many queuing services and worker
services, ID-Generator services and all logical API for
Cloud Storage System. This layer implements business
logic part in BFC. The most important components of
this layer are upload and download service. In
addition, this layer provides a high scalable service
named CloudAppsService which serves all client
requests . When the number of clients reaches a certain
limited ones, we can deploy CloudAppsService into
more servers for scaling. Clients do not directly
request to CloudAppsService, but through a
dispatcher which provides public APIs for clients. The
dispatcher checks user session before forwarding the
client request to CloudAppsService. Moreover, the
dispatcher also checks the number of connections from
a client, if there are too many concurrent connections
from a client, the dispatcher can block that client’s

requests. Storage Logical Layer stores and retrieves
data from Object Store Layer. Object Store Layer
is the most important layer which has responsibility
for storing and caching objects. This layer manages
information of all objects in the system including user
data, file information data, and especially meta-data.
In BFC system, meta-data describes a file and how it
is organized as a list of small chunks. We implemented
some optimizations to make low-complicated
meta-data. Object Store Layer contains many
distributed backend services. Two important services
of Object Store Layer are FileInfoService and
ChunkStoreService. FileInfoService stores
information of files. It is a key-value store mapping
data from fileID to FileInfo structure.
ChunkStoreService stores data chunks which are
created by splitting from the original files that user
uploaded. The size of each chunk is fixed(the last
chunk of a file may have a smaller size). Splitting and
storing a large file as a list of chunks in distributed
keyvalue store bring a lot of benefits. First of all, it is
easier to store, distribute and replicate chunks in key-
value stores. Small chunks can be stored efficiently in
a key-value store. It is difficult to do this with a large
file directly in local file system. In addition, this
supports uploading and downloading file parallel and
resumable. All data on this layer are persisted to
Persistent Layer based on ZDB [16] key-value store.
There are many ZDB instances which are deployed as
a distributed service and can be scaled when data
growing. Components in these layer are coordinated
and automatically configured using Zookeeper [13].
Fig 1 shows the overview of BFC Architecture.
B. Logical Data layout

Fig 3 shows the layout of big file data. Every file
consists of one or more fixed-size chunks. Each chunk
has an unique integer ID, and all of chunks which
were generated from a file have a contiguous range of
chunk-id. This is a different point to many other Cloud
Service such as DropBox[8] which uses SHA-2[19] of
chunk as ID.
C. Chunk Storage
The basic element in the BFC cloud storage system is
chunk. A chunk is a data segment generated from a
file. When user upload a file, if the file size is bigger
than the configured size, it will be split into a
collection of chunks. All chunks which are generated
from a file except the last chunk havesmaller size).
After that, the ID generator will generate id for the file
and the first chunk with auto-increment mechanism.
Next chunk in the chunks set will be assigned an ID
gradually increase until the final chunk. A FileInfo
object is created with information such as file-id, size
of file, id of first chunk, number of chunks and stored
to ZDB. Similarly, the chunk will be stored in key-
value store as a record with key is id of chunk and
value is chunk data. Chunk storage is one of the most
significant technique of BFC. By using chunks to
represent a file, we can easily build a distributed file
storage system service with replication, load
balancing, fault-tolerant and supporting recovery. Fig
4 describes Chunk Storage System of BFC.
D. Metadata
Typically, in the cloud storage system such as
Dropbox [8], CEPH [24], the size of meta-data will
respectively increase with the size of original file, it
contains a list of elements, each element contains
information such as chunk size, hash value of chunk.
Length of the list is equal to the number of chunk from
file. So it becomes complicated when the file size is
big. BFC proposed a solution in which the size of
meta-data is independent of number of chunks with
any size of file, both a very small file or a huge file.
The solution just stores the id of first chunk, and the
number of chunks which is generated by original file.
Because the id of chunk is increasingly assigned
from the first chunk, we can easily calculate the ith
chunk id by the formula:
chunkid[i] = fileInfo.startChunkID + i (1)

Meta-data is mainly described in FileInfo structure
consist of following fields: fileName - the name of file;
fileID: 8
bytes - unique identification of file in the whole
system ;
sha256 : 32 bytes - hash value by using sha-256
algorithm
of file data; refFileID: 8 bytes - id of file that have
previous existed in System and have the same sha256
- we treat these files as one, refFileID is valid if it is
greater than zero;
startChunkID : 8 bytes - the identification of the first
chunk of file, the next chunk will have id as
startChunkID+1 and so on; numChunk: 8 bytes - the
number of chunks of the file; fileSize : 8 bytes - size of
file in bytes; status: enum 1 bytes - the status of file, it
has one in four values namely
EUploadingFile - when chunk are uploading to server,
ECompletedF ile - when all chunk are uploaded to
server but it is not check as consistent, ECorruptedF
ile – when all chunk are uploaded to server but it is not
consistent after checking, EGoodCompleted - when all
chunk are uploaded to server and consistent checking
completed with good result. Thus the size of FileInfo
object - the meta-data of a file will be nearly the same
for all file in the system, regardless of how large or
small the file size is (the only difference meta-data
of files is the length of fileName). By using this
solution, we created a lightweight meta-data design
when building a big file storage system. Fig 5
describes meta-data store system of BFC.
E. Data distribution and replication
Because BFC is built based on ZDB - a distributed
keyvalue storage system. It is obvious that the meta-
data of BFC is stored distributed and can be replicated
for fault-tolerance and load-balancing. Store Services
such as FileInfoService, ChunkStoreService distribute
data using consistent-hashing which is proposed
in[15]. Chain replication [23]is used to replicate key-
value data. Each type of store service has its own
distributed ZDB instances. Each ZDB instance has a
range [hlowerbound, hupperbound) which is used to
determine the range of key to store. If hash(key) is in
the range, it is stored in that instance. In BFC, file-id
and chunk-id are auto increment integer keys. We can
use simple hash function.

F. Uploading and deduplication algorithm
Fig 7 describes an algorithm for uploading big file to
BFC. Data deduplication is supported in BFC. There
are many types and methods of data deduplication [21]
which can work both on client-side or server-side. In
BFC, we implemented it on server-side. We use a
simple method with key-value store and SHA2 hash
function to detect duplicate files in the whole system
in the flow of uploading. A comparison between BFC
and other cloud storage systems in deduplication is
shown in
Table I in Section III
The upload flow on BFC cloud storage system has a
little different between mobile client and web
interface. On mobile client, after a file to upload is
selected, we call it A, the client computes the SHA
hash value of content of this file. After that, the client
creates a basic information of file including file name,
file size, SHA value. This basic information will be
sent to server. At server-side, if data deduplication is
enabled, SHA value will be used to lookup associated
fileID, if there is a fileID in the system with the SHA-
value we call it B, this means that file A and file B are
exactly the same. So we simply refer file A to file B
by assigning the id of file B to0020refFileID property
of file A - a property to describe that a file is
referenced to another file. The basic information will
be sent back to client , and the upload flow complete,
there is no more wasteful upload. In the case there is
no fileID associated with SHA-value of file A or data
deduplication is disabled, the system will create some
of new properties for the file information including the
id of file, the id of first chunk using IDGenerator and
number of chunk calculated by file size and chunk
size. The client will use this information to upload file
content to the server. Then, all chunks will be
uploaded to the server. This process can be executed in
parallel to maximize speed. Every chunk will be stored
in the storage system as a key-value pair, with the key
is the id of chunk, and the value is data content of the
chunk. When all chunk are uploaded to the system,
there is a procedure to verify uploaded data such as
verifying the equation of SHA-value calculated by
client and SHA-value of file created by uploaded
chunk in server. If everything is good, the status of
field of FileInfo is set to EGoodCompleted. In web-
interface client upload process, the client always
uploads the file to server and saves it in a temporary
directory. Then the server computes SHA hash value
of the uploaded file. If there is any file in the system
which has the same SHA value with it. Server will
refer the uploaded file with this file and remove the
file at temporary directory. Otherwise, A worker
service called FileAdder will upload file to the system
using similar algorithm of the mobile application
client.
G. Downloading algorithm
Mobile clients of BFC have download algorithms
described in Fig 8. Firstly, the client sends the id of
file that will be downloaded to the server. The
dispatcher server will check the session and number of
connection from the client. If they are valid, the
dispatcher sends download request to the
CloudAppsService server, then it will lookup the file
information in the FileInfoService which stores meta-
data information with file-ID as a key. If FileInfo is
existed with the requested file-ID, this information
will be sent back to the client. The most important
information of the file from FileInfo structure
includes: first id of chunk (chunkIdStart), number of
chunk (chunkNumber), size of chunk (chunkSize) and
size of File (fileSize). The client uses these information
to schedule the download process. After that, the

mobile client downloads chunks of files from
ChunkStoreService via CloudAppDispatcher and
CloudAppService, chunks with range ID from
chunkIdStart to chunkIdStart+numberChunk−1 are
concurrently down5 loaded in several threads, each
chunk has a size of chunkSize, except last chunk.
Native application will pre-allocate file in local
filesystem with file-size specified in fileSize field of
FileInfo. Every downloaded chunk will be save
directly to its position in this file. When all chunks are
fully downloaded successful, the download process is
completed.
H. Secure Data Transfer Protocol
Data confidentiality is one of strict requirements of
cloud storage system. To ensure quality of service, a
light-weight and fast network protocol for transfer data
is also required. For web-interface and restful APIs,
we support http secure protocol (https) to protect the
connection from catching packets in all operations. In
both desktop and mobile native applications, BFC
Data transfered over Internet between client and server
are encrypted using AES[9] algorithms with simple
key exchange between client and server. We also use
UDT [12] - an UDP-based protocol to use network
bandwidth efficiently.
This is detail of simple key exchange method:
– When an user login via https restful API, client
receive Session-ID, User-ID, Secret-AES key, Public
Key- Index. Secret-AES key is secret between client
and server, it can be generated by client or server and
stored on server as a key-list. It is used to encrypt
chunks for transferring between client and server.
– In every operation such as uploading or
downloading chunks, the data is encrypted using
secret-AES key and transferred via network using
UDT or TCP as client selected. Public Key-index is
binded with encrypted packets for peer to determine
secret AES key to decrypt received packets.

III. COMPARISON WITH OTHER PERSONAL
CLOUD STORAGES
In a paper of Idilio Drago et al [7], many personal
cloud storages were benchmarked in a black-box
evaluation method. The test cases in [7] used files with
size: 10kB, 100kB, 1MB to compare Dropbox,
SkyDrive, Cloud Drive, Google Drive and Wuala. In
this research, we deployed an instance of BFC system
in Amazon EC2 to compare with Dropbox which uses
Amazon EC2 and Amazon S3. Clients of both BFC
and Dropbox run from VietNam. According to paper
[8] about some aspects inside Dropbox, we compared
BFC’s metadata with Dropbox. Then, we did
experiments for comparing deduplication ability of
BFC and other cloud storages such as Google Drive,
Dropbox, OneDrive.
A. Metadata comparison
Dropbox[8] is a cloud-based storage system that
allows users to store documents, photos, videos and
other files. Dropbox is available on Web interface, and
many types of client softwares on desktop and mobile
operating systems. The client supports synchronization
and sharing between devices with personal storage.
Dropbox were primarily written in Python. The native
client uses third parties libraries such as wxWidgets,
Cocoa, librsync. The basic object in the Dropbox
system is a chunk of 4MB data. If a file is larger than
this configured size, it will be split in several of basic
objects. Each basic object is and stored in Amazon
Simple Storage Service (S3). Metadata of each file in
Dropbox contains a list of SHA256 of its chunks [1],
[8]. Therefore, its size is linear to the size of file. For
bigfile, it has a big metadata caused by many of
chunks and a long list of SHA256 values from them.
In our research BFC has a fixed-size metadata of each
file, so it is easier to store and scale storage system for
big file. It reduces the amount of data for exchanging
metadata between clients and servers.
The comparison is shown in Fig 9.
B. Deduplication
This comparison was done to study the deduplication
ability of BFC and other cloud storages: Dropbox,
OneDrive and Google Drive. We used WireShark [6]
to capture network flow of cloud storage client
application. To estimate the deduplication ability, we
did following test cases: (1) A file is multiply
uploaded to different folders by a User; (2) A file is
multiply uploaded by different users. The result in
Table I showed that Dropbox supports deduplication
per user accounts, it could be done in client
applications. BFC support a global deduplication
mechanism, it saves the network traffic and internal
storage space when many users store the same file
content. Google Drive and OneDrive do not support
deduplication.
IV. RELATED WORKS
LevelDB [10] is an open source key-value store
developed by Google Fellows Jeffrey Dean and Sanjay
Ghemawat, originated from BigTable [5]. LevelDB
implements LSM-tree [17] and consists of two
MemTable and set of SSTables on disk in multiple
levels. When a key-value pair is written, it firstly is
appended to commit log file, then it is inserted into a
sorted structure called MemTable. When MemTable’s
size reaches its limit capacity, it will become a read-
only Immutable MemTable. Then a new MemTable is
created to handle new updates. Immutable MemTable
is converted to a level-0 SSTable on disk by a
background thread. SSTables which reach the level’s
limit size, will be merged to create a higher level
SSTable. We already evaluated LevelDB in our prior
work [16] and the results show that LevelDB is very
fast for small key-value pairs and data set. When data
growing
time-by-time and with large key-value pairs, LevelDB
become slow for both writing and reading. Zing-
database (ZDB) [16] is a high performance keyvalue
store that is optimized for auto increment Integer-key.

It has a shared-memory flat index for fast looking-up
position of key-value entries in data files. ZDB
supports sequential writes, random read. ZDB is
served in ZDBService using thrift protocol and
distribute data using consistent-hash method. In BFC,
both file-id and chunk-id are auto increment integer
keys, so it is very good to use ZDB to store data. The
advantage of ZDB is lightweight memory index and
performance for big data. When data grow it still has a
low-latency for read and write operation. Many other
researches try to optimize famous data structures such
as B+tree [14] on SSD, HDD or hybrid storage device.
It is also useful for building key-value stores on these
data structures. With the design and architecture of
BFC, the chunkId of a file has a contiguous integer
range, ZDB is still the most effective to store chunk
data.
Distributed Storage Systems (DSS) are
storage systems designed to operate on network
environment including Local Area Network(LAN) and
the Internet. In DSS, data is distributed to many
servers with ability to serve millions of users [18].
DSS can be used to provide backup and retrieve data
functions. BFC fully supports these functions. DSS
also provide services as a general purpose file system
such as NFS [20] or other Distributed File System
(DFS) such as GFS [11].
BFC is persistent non-volatile cloud storage, so it can
provide this function in Linux by using FUSE[22] and
BFC client protocol. Applications store data on BFC
can take advantages of its high performance and
parallel processing ability.
V. CONCLUSION
BFC designed a simple meta-data to create a high
performance Cloud Storage based on ZDB key-value
store. Every file in the system has a same size of meta-
data regardless of file size. Every big-file stored in
BFC is split into multiple fixed size chunks (may
except the last chunk of file). The chunks of a file have
a contiguous ID range, thus it is easy to distribute
data and scale-out storage system, especially when
using ZDB. This research also brings the advantages
of key-value store into big-file data store which is not
default supported for big-value. ZDB[16] is used for
supporting sequential write, small memory-index
overhead. The data Deduplication method of BFC uses
SHA-2 hash function and a key-value store to fast
detect data-duplication on server-side. It is useful to
save storage space and network bandwidth when many
users upload the same static data. In the future, we will
continue to research and improve our ideas for storing
big data structure in larger domain of applications,
especially in the ”Internet of things” trend.
VI. ACKNOWLEDGMENTS
This work was funded by the Research Fund
RF@K12, Faculty of Information Technology, Le Quy
Don Technical University. CSM Boot diskless and
Zing Me social network of VNG Corporation
supported infrastructure and its data for this research’s
analysis and experiments.
REFERENCES
[1] Dropbox tech blog. https://tech.dropbox.com/.
Accessed October 28, 2014.
[2] Zing me. http://me.zing.vn. Accessed October 28,
2014.
[3] Facebook. http://facebook.com, 2014.
[4] D. Borthakur. Hdfs architecture guide. HADOOP
APACHE PROJECT
http://hadoop. apache. org/common/docs/current/hdfs
design. pdf, 2008.
[5] F. Chang, J. Dean, S. Ghemawat, W. C. Hsieh, D.
A. Wallach, M. Burrows, T. Chandra, A. Fikes, and R.
E. Gruber. Bigtable: A distributed storage system for
structured data. ACM Transactions on Computer
Systems (TOCS), 26(2):4, 2008.
[6] L. Chappell and G. Combs. Wireshark network
analysis: the official Wireshark certified network
analyst study guide. Protocol Analysis

IDL - International Digital Library 10 | P a g e Copyright@IDL-
2017
Institute, Chappell University, 2010.
[7] I. Drago, E. Bocchi, M. Mellia, H. Slatman, and A.
Pras. Benchmarking personal cloud storage. In
Proceedings of the 2013 conference on Internet
measurement conference, pages 205–212. ACM, 2013.
[8] I. Drago, M. Mellia, M. M Munafo, A. Sperotto, R.
Sadre, and A. Pras. Inside dropbox: understanding
personal cloud storage services. In Proceedings of the
2012 ACM conference on Internet measurement
conference, pages 481–494. ACM, 2012.
[9] P. FIPS. 197: the official aes standard. Figure2:
Working scheme with four LFSRs and their IV
generation LFSR1 LFSR, 2, 2001.
[10] S. Ghemawat and J. Dean. Leveldb is a fast key-
value storage library written at google that provides an
ordered mapping from string keys to string values.
https://github.com/google/leveldb. Accessed
November 2, 2014.
[11] S. Ghemawat, H. Gobioff, and S.-T. Leung. The
google file system. In ACM SIGOPS Operating
Systems Review, volume 37, pages 29–43. ACM,
2003.
[12] Y. Gu and R. L. Grossman. Udt: Udp-based data
transfer for high-speed wide area networks. Computer
Networks, 51(7):1777–1799, 2007.
[13] P. Hunt, M. Konar, F. P. Junqueira, and B. Reed.
Zookeeper: wait-free coordination for internet-scale
systems. In Proceedings of the 2010 USENIX
conference on USENIX annual technical conference,
volume 8, pages 11–11, 2010.
[14] P. Jin, P. Yang, and L. Yue. Optimizing b+-tree
for hybrid storage systems. Distributed and Parallel
Databases, pages 1–27, 2014.
[15] D. Karger, A. Sherman, A. Berkheimer, B.
Bogstad, R. Dhanidina, K. Iwamoto, B. Kim, L.
Matkins, and Y. Yerushalmi. Web caching with
consistent hashing. Computer Networks, 31(11):1203–
1213, 1999.
[16] T. Nguyen and M. Nguyen. Zing database: high-
performance key-value store for large-scale storage
service. Vietnam Journal of Computer
Science, pages 1–11, 2014.
[17] P. ONeil, E. Cheng, D. Gawlick, and E. ONeil.
The log-structured merge-tree (lsm-tree). Acta
Informatica, 33(4):351–385, 1996.
[18] M. Placek and R. Buyya. A taxonomy of
distributed storage systems. Reporte t´ecnico,
Universidad de Melbourne, Laboratorio de sistemas
distribuidos y c´omputo grid, 2006.
[19] F. PUB. Secure hash standard (shs). 2012.
[20] S. Shepler, M. Eisler, D. Robinson, B. Callaghan,
R. Thurlow, D. Noveck, and C. Beame. Network file
system (nfs) version 4 protocol. Network, 2003.
[21] J. Stanek, A. Sorniotti, E. Androulaki, and L.
Kencl. A secure data deduplication scheme for cloud
storage. 2014.
[22] M. Szeredi et al. Fuse: Filesystem in userspace.
Accessed on, 2010.
[23] R. van Renesse and F. B. Schneider. Chain
replication for supporting high throughput and
availability. In OSDI, volume 4, pages 91–104,
2004.
[24] S. A. Weil, S. A. Brandt, E. L. Miller, D. D. E.
Long, and C. Maltzahn. Ceph: A scalable, high-
performance distributed file system. In Proceedings
of the 7th Symposium on Operating Systems Design
and Implementation, OSDI ’06, pages 307–320,
Berkeley, CA, USA, 2006. USENIX Association.

BFC: High-Performance Distributed Big-File Cloud Storage Based On Key-Value Store

Recommended

More Related Content

What's hot (17)

Similar to BFC: High-Performance Distributed Big-File Cloud Storage Based On Key-Value Store (20)

Recently uploaded (20)

BFC: High-Performance Distributed Big-File Cloud Storage Based On Key-Value Store