提供基本的ttl测试用例
No puede seleccionar más de 25 temas Los temas deben comenzar con una letra o número, pueden incluir guiones ('-') y pueden tener hasta 35 caracteres de largo.

100 líneas
3.5 KiB

  1. // Copyright (c) 2011 The LevelDB Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file. See the AUTHORS file for names of contributors.
  4. //
  5. // This file contains the specification, but not the implementations,
  6. // of the types/operations/etc. that should be defined by a platform
  7. // specific port_<platform>.h file. Use this file as a reference for
  8. // how to port this package to a new platform.
  9. #ifndef STORAGE_LEVELDB_PORT_PORT_EXAMPLE_H_
  10. #define STORAGE_LEVELDB_PORT_PORT_EXAMPLE_H_
  11. #include "port/thread_annotations.h"
  12. namespace leveldb {
  13. namespace port {
  14. // TODO(jorlow): Many of these belong more in the environment class rather than
  15. // here. We should try moving them and see if it affects perf.
  16. // ------------------ Threading -------------------
  17. // A Mutex represents an exclusive lock.
  18. class LOCKABLE Mutex {
  19. public:
  20. Mutex();
  21. ~Mutex();
  22. // Lock the mutex. Waits until other lockers have exited.
  23. // Will deadlock if the mutex is already locked by this thread.
  24. void Lock() EXCLUSIVE_LOCK_FUNCTION();
  25. // Unlock the mutex.
  26. // REQUIRES: This mutex was locked by this thread.
  27. void Unlock() UNLOCK_FUNCTION();
  28. // Optionally crash if this thread does not hold this mutex.
  29. // The implementation must be fast, especially if NDEBUG is
  30. // defined. The implementation is allowed to skip all checks.
  31. void AssertHeld() ASSERT_EXCLUSIVE_LOCK();
  32. };
  33. class CondVar {
  34. public:
  35. explicit CondVar(Mutex* mu);
  36. ~CondVar();
  37. // Atomically release *mu and block on this condition variable until
  38. // either a call to SignalAll(), or a call to Signal() that picks
  39. // this thread to wakeup.
  40. // REQUIRES: this thread holds *mu
  41. void Wait();
  42. // If there are some threads waiting, wake up at least one of them.
  43. void Signal();
  44. // Wake up all waiting threads.
  45. void SignallAll();
  46. };
  47. // ------------------ Compression -------------------
  48. // Store the snappy compression of "input[0,input_length-1]" in *output.
  49. // Returns false if snappy is not supported by this port.
  50. bool Snappy_Compress(const char* input, size_t input_length,
  51. std::string* output);
  52. // If input[0,input_length-1] looks like a valid snappy compressed
  53. // buffer, store the size of the uncompressed data in *result and
  54. // return true. Else return false.
  55. bool Snappy_GetUncompressedLength(const char* input, size_t length,
  56. size_t* result);
  57. // Attempt to snappy uncompress input[0,input_length-1] into *output.
  58. // Returns true if successful, false if the input is invalid lightweight
  59. // compressed data.
  60. //
  61. // REQUIRES: at least the first "n" bytes of output[] must be writable
  62. // where "n" is the result of a successful call to
  63. // Snappy_GetUncompressedLength.
  64. bool Snappy_Uncompress(const char* input_data, size_t input_length,
  65. char* output);
  66. // ------------------ Miscellaneous -------------------
  67. // If heap profiling is not supported, returns false.
  68. // Else repeatedly calls (*func)(arg, data, n) and then returns true.
  69. // The concatenation of all "data[0,n-1]" fragments is the heap profile.
  70. bool GetHeapProfile(void (*func)(void*, const char*, int), void* arg);
  71. // Extend the CRC to include the first n bytes of buf.
  72. //
  73. // Returns zero if the CRC cannot be extended using acceleration, else returns
  74. // the newly extended CRC value (which may also be zero).
  75. uint32_t AcceleratedCRC32C(uint32_t crc, const char* buf, size_t size);
  76. } // namespace port
  77. } // namespace leveldb
  78. #endif // STORAGE_LEVELDB_PORT_PORT_EXAMPLE_H_