小组成员:10215300402-朱维清 & 10222140408 谷杰
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

138 lines
6.5 KiB

Release 1.18 Changes are: * Update version number to 1.18 * Replace the basic fprintf call with a call to fwrite in order to work around the apparent compiler optimization/rewrite failure that we are seeing with the new toolchain/iOS SDKs provided with Xcode6 and iOS8. * Fix ALL the header guards. * Createed a README.md with the LevelDB project description. * A new CONTRIBUTING file. * Don't implicitly convert uint64_t to size_t or int. Either preserve it as uint64_t, or explicitly cast. This fixes MSVC warnings about possible value truncation when compiling this code in Chromium. * Added a DumpFile() library function that encapsulates the guts of the "leveldbutil dump" command. This will allow clients to dump data to their log files instead of stdout. It will also allow clients to supply their own environment. * leveldb: Remove unused function 'ConsumeChar'. * leveldbutil: Remove unused member variables from WriteBatchItemPrinter. * OpenBSD, NetBSD and DragonflyBSD have _LITTLE_ENDIAN, so define PLATFORM_IS_LITTLE_ENDIAN like on FreeBSD. This fixes: * issue #143 * issue #198 * issue #249 * Switch from <cstdatomic> to <atomic>. The former never made it into the standard and doesn't exist in modern gcc versions at all. The later contains everything that leveldb was using from the former. This problem was noticed when porting to Portable Native Client where no memory barrier is defined. The fact that <cstdatomic> is missing normally goes unnoticed since memory barriers are defined for most architectures. * Make Hash() treat its input as unsigned. Before this change LevelDB files from platforms with different signedness of char were not compatible. This change fixes: issue #243 * Verify checksums of index/meta/filter blocks when paranoid_checks set. * Invoke all tools for iOS with xcrun. (This was causing problems with the new XCode 5.1.1 image on pulse.) * include <sys/stat.h> only once, and fix the following linter warning: "Found C system header after C++ system header" * When encountering a corrupted table file, return Status::Corruption instead of Status::InvalidArgument. * Support cygwin as build platform, patch is from https://code.google.com/p/leveldb/issues/detail?id=188 * Fix typo, merge patch from https://code.google.com/p/leveldb/issues/detail?id=159 * Fix typos and comments, and address the following two issues: * issue #166 * issue #241 * Add missing db synchronize after "fillseq" in the benchmark. * Removed unused variable in SeekRandom: value (issue #201)
10 years ago
  1. **LevelDB is a fast key-value storage library written at Google that provides an ordered mapping from string keys to string values.**
  2. Authors: Sanjay Ghemawat (sanjay@google.com) and Jeff Dean (jeff@google.com)
  3. # Features
  4. * Keys and values are arbitrary byte arrays.
  5. * Data is stored sorted by key.
  6. * Callers can provide a custom comparison function to override the sort order.
  7. * The basic operations are `Put(key,value)`, `Get(key)`, `Delete(key)`.
  8. * Multiple changes can be made in one atomic batch.
  9. * Users can create a transient snapshot to get a consistent view of data.
  10. * Forward and backward iteration is supported over the data.
  11. * Data is automatically compressed using the [Snappy compression library](http://code.google.com/p/snappy).
  12. * External activity (file system operations etc.) is relayed through a virtual interface so users can customize the operating system interactions.
  13. * [Detailed documentation](http://htmlpreview.github.io/?https://github.com/google/leveldb/blob/master/doc/index.html) about how to use the library is included with the source code.
  14. # Limitations
  15. * This is not a SQL database. It does not have a relational data model, it does not support SQL queries, and it has no support for indexes.
  16. * Only a single process (possibly multi-threaded) can access a particular database at a time.
  17. * There is no client-server support builtin to the library. An application that needs such support will have to wrap their own server around the library.
  18. # Performance
  19. Here is a performance report (with explanations) from the run of the
  20. included db_bench program. The results are somewhat noisy, but should
  21. be enough to get a ballpark performance estimate.
  22. ## Setup
  23. We use a database with a million entries. Each entry has a 16 byte
  24. key, and a 100 byte value. Values used by the benchmark compress to
  25. about half their original size.
  26. LevelDB: version 1.1
  27. Date: Sun May 1 12:11:26 2011
  28. CPU: 4 x Intel(R) Core(TM)2 Quad CPU Q6600 @ 2.40GHz
  29. CPUCache: 4096 KB
  30. Keys: 16 bytes each
  31. Values: 100 bytes each (50 bytes after compression)
  32. Entries: 1000000
  33. Raw Size: 110.6 MB (estimated)
  34. File Size: 62.9 MB (estimated)
  35. ## Write performance
  36. The "fill" benchmarks create a brand new database, in either
  37. sequential, or random order. The "fillsync" benchmark flushes data
  38. from the operating system to the disk after every operation; the other
  39. write operations leave the data sitting in the operating system buffer
  40. cache for a while. The "overwrite" benchmark does random writes that
  41. update existing keys in the database.
  42. fillseq : 1.765 micros/op; 62.7 MB/s
  43. fillsync : 268.409 micros/op; 0.4 MB/s (10000 ops)
  44. fillrandom : 2.460 micros/op; 45.0 MB/s
  45. overwrite : 2.380 micros/op; 46.5 MB/s
  46. Each "op" above corresponds to a write of a single key/value pair.
  47. I.e., a random write benchmark goes at approximately 400,000 writes per second.
  48. Each "fillsync" operation costs much less (0.3 millisecond)
  49. than a disk seek (typically 10 milliseconds). We suspect that this is
  50. because the hard disk itself is buffering the update in its memory and
  51. responding before the data has been written to the platter. This may
  52. or may not be safe based on whether or not the hard disk has enough
  53. power to save its memory in the event of a power failure.
  54. ## Read performance
  55. We list the performance of reading sequentially in both the forward
  56. and reverse direction, and also the performance of a random lookup.
  57. Note that the database created by the benchmark is quite small.
  58. Therefore the report characterizes the performance of leveldb when the
  59. working set fits in memory. The cost of reading a piece of data that
  60. is not present in the operating system buffer cache will be dominated
  61. by the one or two disk seeks needed to fetch the data from disk.
  62. Write performance will be mostly unaffected by whether or not the
  63. working set fits in memory.
  64. readrandom : 16.677 micros/op; (approximately 60,000 reads per second)
  65. readseq : 0.476 micros/op; 232.3 MB/s
  66. readreverse : 0.724 micros/op; 152.9 MB/s
  67. LevelDB compacts its underlying storage data in the background to
  68. improve read performance. The results listed above were done
  69. immediately after a lot of random writes. The results after
  70. compactions (which are usually triggered automatically) are better.
  71. readrandom : 11.602 micros/op; (approximately 85,000 reads per second)
  72. readseq : 0.423 micros/op; 261.8 MB/s
  73. readreverse : 0.663 micros/op; 166.9 MB/s
  74. Some of the high cost of reads comes from repeated decompression of blocks
  75. read from disk. If we supply enough cache to the leveldb so it can hold the
  76. uncompressed blocks in memory, the read performance improves again:
  77. readrandom : 9.775 micros/op; (approximately 100,000 reads per second before compaction)
  78. readrandom : 5.215 micros/op; (approximately 190,000 reads per second after compaction)
  79. ## Repository contents
  80. See doc/index.html for more explanation. See doc/impl.html for a brief overview of the implementation.
  81. The public interface is in include/*.h. Callers should not include or
  82. rely on the details of any other header files in this package. Those
  83. internal APIs may be changed without warning.
  84. Guide to header files:
  85. * **include/db.h**: Main interface to the DB: Start here
  86. * **include/options.h**: Control over the behavior of an entire database,
  87. and also control over the behavior of individual reads and writes.
  88. * **include/comparator.h**: Abstraction for user-specified comparison function.
  89. If you want just bytewise comparison of keys, you can use the default
  90. comparator, but clients can write their own comparator implementations if they
  91. want custom ordering (e.g. to handle different character encodings, etc.)
  92. * **include/iterator.h**: Interface for iterating over data. You can get
  93. an iterator from a DB object.
  94. * **include/write_batch.h**: Interface for atomically applying multiple
  95. updates to a database.
  96. * **include/slice.h**: A simple module for maintaining a pointer and a
  97. length into some other byte array.
  98. * **include/status.h**: Status is returned from many of the public interfaces
  99. and is used to report success and various kinds of errors.
  100. * **include/env.h**:
  101. Abstraction of the OS environment. A posix implementation of this interface is
  102. in util/env_posix.cc
  103. * **include/table.h, include/table_builder.h**: Lower-level modules that most
  104. clients probably won't use directly