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  
 10  #ifndef STORAGE_LEVELDB_PORT_PORT_EXAMPLE_H_
 11  #define STORAGE_LEVELDB_PORT_PORT_EXAMPLE_H_
 12  
 13  #include "port/thread_annotations.h"
 14  
 15  namespace leveldb {
 16  namespace port {
 17  
 18  // TODO(jorlow): Many of these belong more in the environment class rather than
 19  //               here. We should try moving them and see if it affects perf.
 20  
 21  // ------------------ Threading -------------------
 22  
 23  // A Mutex represents an exclusive lock.
 24  class LOCKABLE Mutex {
 25   public:
 26    Mutex();
 27    ~Mutex();
 28  
 29    // Lock the mutex.  Waits until other lockers have exited.
 30    // Will deadlock if the mutex is already locked by this thread.
 31    void Lock() EXCLUSIVE_LOCK_FUNCTION();
 32  
 33    // Unlock the mutex.
 34    // REQUIRES: This mutex was locked by this thread.
 35    void Unlock() UNLOCK_FUNCTION();
 36  
 37    // Optionally crash if this thread does not hold this mutex.
 38    // The implementation must be fast, especially if NDEBUG is
 39    // defined.  The implementation is allowed to skip all checks.
 40    void AssertHeld() ASSERT_EXCLUSIVE_LOCK();
 41  };
 42  
 43  class CondVar {
 44   public:
 45    explicit CondVar(Mutex* mu);
 46    ~CondVar();
 47  
 48    // Atomically release *mu and block on this condition variable until
 49    // either a call to SignalAll(), or a call to Signal() that picks
 50    // this thread to wakeup.
 51    // REQUIRES: this thread holds *mu
 52    void Wait();
 53  
 54    // If there are some threads waiting, wake up at least one of them.
 55    void Signal();
 56  
 57    // Wake up all waiting threads.
 58    void SignallAll();
 59  };
 60  
 61  // ------------------ Compression -------------------
 62  
 63  // Store the snappy compression of "input[0,input_length-1]" in *output.
 64  // Returns false if snappy is not supported by this port.
 65  bool Snappy_Compress(const char* input, size_t input_length,
 66                       std::string* output);
 67  
 68  // If input[0,input_length-1] looks like a valid snappy compressed
 69  // buffer, store the size of the uncompressed data in *result and
 70  // return true.  Else return false.
 71  bool Snappy_GetUncompressedLength(const char* input, size_t length,
 72                                    size_t* result);
 73  
 74  // Attempt to snappy uncompress input[0,input_length-1] into *output.
 75  // Returns true if successful, false if the input is invalid lightweight
 76  // compressed data.
 77  //
 78  // REQUIRES: at least the first "n" bytes of output[] must be writable
 79  // where "n" is the result of a successful call to
 80  // Snappy_GetUncompressedLength.
 81  bool Snappy_Uncompress(const char* input_data, size_t input_length,
 82                         char* output);
 83  
 84  // ------------------ Miscellaneous -------------------
 85  
 86  // If heap profiling is not supported, returns false.
 87  // Else repeatedly calls (*func)(arg, data, n) and then returns true.
 88  // The concatenation of all "data[0,n-1]" fragments is the heap profile.
 89  bool GetHeapProfile(void (*func)(void*, const char*, int), void* arg);
 90  
 91  // Extend the CRC to include the first n bytes of buf.
 92  //
 93  // Returns zero if the CRC cannot be extended using acceleration, else returns
 94  // the newly extended CRC value (which may also be zero).
 95  uint32_t AcceleratedCRC32C(uint32_t crc, const char* buf, size_t size);
 96  
 97  }  // namespace port
 98  }  // namespace leveldb
 99  
100  #endif  // STORAGE_LEVELDB_PORT_PORT_EXAMPLE_H_