shared_mem_cache.h

Go to the documentation of this file.

/*
 * Copyright 2010 Google Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http:///www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */


#ifndef PAGESPEED_KERNEL_SHAREDMEM_SHARED_MEM_CACHE_H_
#define PAGESPEED_KERNEL_SHAREDMEM_SHARED_MEM_CACHE_H_

#include <cstddef>
#include <vector>

#include "pagespeed/kernel/base/basictypes.h"
#include "pagespeed/kernel/base/cache_interface.h"
#include "pagespeed/kernel/base/scoped_ptr.h"
#include "pagespeed/kernel/base/shared_string.h"
#include "pagespeed/kernel/base/string.h"
#include "pagespeed/kernel/base/string_util.h"
#include "pagespeed/kernel/base/thread_annotations.h"
#include "pagespeed/kernel/cache/file_cache.h"
#include "pagespeed/kernel/sharedmem/shared_mem_cache_data.h"

namespace net_instaweb {

class AbstractSharedMem;
class AbstractSharedMemSegment;
class Hasher;
class MessageHandler;
class SharedMemCacheDump;
class Timer;

template<size_t kBlockSize>
class SharedMemCache : public CacheInterface {
 public:
  static const int kAssociativity = 4; 

  SharedMemCache(AbstractSharedMem* shm_runtime, const GoogleString& filename,
                 Timer* timer, const Hasher* hasher, int sectors,
                 int entries_per_sector, int blocks_per_sector,
                 MessageHandler* handler);

  virtual ~SharedMemCache();

  bool Initialize();

  bool Attach();

  static void GlobalCleanup(AbstractSharedMem* shm_runtime,
                            const GoogleString& filename,
                            MessageHandler* message_handler);

  static void ComputeDimensions(int64 size_kb,
                                int block_entry_ratio,
                                int sectors,
                                int* entries_per_sector_out,
                                int* blocks_per_sector_out,
                                int64* size_cap_out);

  size_t MaxValueSize() const {
    return (blocks_per_sector_ * kBlockSize) / 8;
  }

  GoogleString DumpStats();

  bool AddSectorToSnapshot(int sector_num, int64 last_checkpoint_ms,
                           SharedMemCacheDump* dest);

  void RestoreSnapshot(const SharedMemCacheDump& dump);

  static void MarshalSnapshot(const SharedMemCacheDump& dump,
                              GoogleString* out);
  static void DemarshalSnapshot(const StringPiece& marshaled,
                                SharedMemCacheDump* out);

  virtual void Get(const GoogleString& key, Callback* callback);
  virtual void Put(const GoogleString& key, const SharedString& value);
  virtual void Delete(const GoogleString& key);
  static GoogleString FormatName();
  virtual GoogleString Name() const { return FormatName();}

  virtual bool IsBlocking() const { return true; }
  virtual bool IsHealthy() const { return true; }
  virtual void ShutDown() {
  }

  void SanityCheck();

  void RegisterSnapshotFileCache(FileCache* potential_file_cache,
                                 int checkpoint_interval_sec);

  StringPiece snapshot_path() const { return snapshot_path_; }
  FileCache* file_cache() const { return file_cache_; }

  int64 GetLastWriteMsForTesting(int sector_num);
  void SetLastWriteMsForTesting(int sector_num, int64 last_checkpoint_ms);

  void WriteOutSnapshotForTesting(int sector_num, int64 last_checkpoint_ms) {
    WriteOutSnapshotFromWorkerThread(sector_num, last_checkpoint_ms);
  }

 private:
  class WriteOutSnapshotFunction;

  struct Position {
    int sector;
    SharedMemCacheData::EntryNum keys[kAssociativity];
  };

  bool InitCache(bool parent);

  void PutRawHash(const GoogleString& raw_hash, int64 last_use_timestamp_ms,
                  const SharedString& value, bool checkpoint_ok);

  CacheInterface::KeyState GetFromEntry(
      const GoogleString& key,
      SharedMemCacheData::Sector<kBlockSize>* sector,
      SharedMemCacheData::EntryNum entry_num,
      Callback* str) EXCLUSIVE_LOCKS_REQUIRED(sector->mutex());

  void PutIntoEntry(SharedMemCacheData::Sector<kBlockSize>* sector,
                    SharedMemCacheData::EntryNum entry_num,
                    int64 last_use_timestamp_ms, const SharedString& value)
      EXCLUSIVE_LOCKS_REQUIRED(sector->mutex());

  void DeleteEntry(SharedMemCacheData::Sector<kBlockSize>* sector,
                   SharedMemCacheData::EntryNum entry_num)
      EXCLUSIVE_LOCKS_REQUIRED(sector->mutex());

  bool TryAllocateBlocks(SharedMemCacheData::Sector<kBlockSize>* sector,
                         int goal, SharedMemCacheData::BlockVector* blocks)
      EXCLUSIVE_LOCKS_REQUIRED(sector->mutex());

  void MarkEntryFree(SharedMemCacheData::Sector<kBlockSize>* sector,
                     SharedMemCacheData::EntryNum entry_num);

  void TouchEntry(SharedMemCacheData::Sector<kBlockSize>* sector,
                  int64 last_use_timestamp_ms,
                  SharedMemCacheData::EntryNum entry_num);

  bool Writeable(const SharedMemCacheData::CacheEntry* entry);

  bool KeyMatch(SharedMemCacheData::CacheEntry* entry,
                const GoogleString& raw_hash);

  GoogleString ToRawHash(const GoogleString& key);

  void ExtractPosition(const GoogleString& raw_hash, Position* out_pos);

  void EnsureReadyForWriting(SharedMemCacheData::Sector<kBlockSize>* sector,
                             SharedMemCacheData::CacheEntry* entry)
      EXCLUSIVE_LOCKS_REQUIRED(sector->mutex());

  void RestoreFromDisk();

  void ScheduleSnapshotIfNecessary(bool checkpoint_ok,
                                   int64 last_use_timestamp_ms,
                                   int64 last_checkpoint_ms,
                                   int sector_num);

  void ScheduleSnapshot(int sector_num, int64 last_checkpoint_ms);

  void WriteOutSnapshotFromWorkerThread(int sector_num,
                                        int64 last_checkpoint_ms);

  GoogleString SnapshotCacheKey(int sector_num) const;

  AbstractSharedMem* shm_runtime_;
  const Hasher* hasher_;
  Timer* timer_;
  GoogleString filename_;
  int num_sectors_;
  int entries_per_sector_;
  int blocks_per_sector_;
  int checkpoint_interval_sec_;
  MessageHandler* handler_;
  GoogleString snapshot_path_;
  FileCache* file_cache_;

  scoped_ptr<AbstractSharedMemSegment> segment_;
  std::vector<SharedMemCacheData::Sector<kBlockSize>*> sectors_;

  GoogleString name_;

  
};

}  

#endif