context_registry.h

Go to the documentation of this file.

// Copyright 2016 Google Inc.

#ifndef PAGESPEED_CONTROLLER_CONTEXT_REGISTRY_H_
#define PAGESPEED_CONTROLLER_CONTEXT_REGISTRY_H_

#include <unistd.h>
#include <memory>
#include <unordered_set>

#include "base/logging.h"
#include "pagespeed/kernel/base/abstract_mutex.h"
#include "pagespeed/kernel/base/basictypes.h"
#include "pagespeed/kernel/base/condvar.h"
#include "pagespeed/kernel/base/thread_annotations.h"
#include "pagespeed/kernel/base/thread_system.h"

namespace net_instaweb {


template <typename ContextT>
class ContextRegistry {
 public:
  ContextRegistry(ThreadSystem* thread_system);
  virtual ~ContextRegistry();

  bool TryRegisterContext(ContextT* ctx)
      LOCKS_EXCLUDED(mutex_) WARN_UNUSED_RESULT;
  void RemoveContext(ContextT* ctx) LOCKS_EXCLUDED(mutex_);

  void CancelAllActiveAndWait() LOCKS_EXCLUDED(mutex_);

  void CancelAllActive() LOCKS_EXCLUDED(mutex_);

  bool IsShutdown() const LOCKS_EXCLUDED(mutex_);

  int Size() const LOCKS_EXCLUDED(mutex_);

  bool Empty() const LOCKS_EXCLUDED(mutex_);

 private:
  typedef std::unordered_set<ContextT*> ContextSet;

  std::unique_ptr<ThreadSystem::CondvarCapableMutex> mutex_;
  std::unique_ptr<ThreadSystem::Condvar> condvar_ GUARDED_BY(mutex_);
  bool shutdown_ GUARDED_BY(mutex_);
  ContextSet contexts_ GUARDED_BY(mutex_);
};

template <typename ContextT>
ContextRegistry<ContextT>::ContextRegistry(ThreadSystem* thread_system)
    : mutex_(thread_system->NewMutex()),
      condvar_(mutex_->NewCondvar()),
      shutdown_(false) {
}

template <typename ContextT>
ContextRegistry<ContextT>::~ContextRegistry() {
  DCHECK_EQ(contexts_.size(), 0);
}

template <typename ContextT>
bool ContextRegistry<ContextT>::Empty() const {
  ScopedMutex lock(mutex_.get());
  return contexts_.empty();
}

template <typename ContextT>
int ContextRegistry<ContextT>::Size() const {
  ScopedMutex lock(mutex_.get());
  return static_cast<int>(contexts_.size());
}

template <typename ContextT>
bool ContextRegistry<ContextT>::IsShutdown() const {
  ScopedMutex lock(mutex_.get());
  return shutdown_;
}

template <typename ContextT>
bool ContextRegistry<ContextT>::TryRegisterContext(ContextT* context) {
  CHECK(context != nullptr);

  ScopedMutex lock(mutex_.get());
  bool inserted = false;
  if (!shutdown_) {
    inserted = contexts_.insert(context).second;
    DCHECK(inserted);
  }
  return inserted;
}

template <typename ContextT>
void ContextRegistry<ContextT>::RemoveContext(ContextT* context) {
  ScopedMutex lock(mutex_.get());
  int num_erased = contexts_.erase(context);
  DCHECK_EQ(num_erased, 1);
  if (num_erased > 0 && contexts_.empty() && shutdown_) {
    condvar_->Broadcast();
  }
}

template <typename ContextT>
void ContextRegistry<ContextT>::CancelAllActive() {
  ContextSet old_contexts;
  {
    ScopedMutex lock(mutex_.get());
    shutdown_ = true;
    old_contexts = contexts_;
  }

  if (old_contexts.empty()) {
    return;
  }

  for (ContextT* ctx : old_contexts) {
    mutex_->Lock();
    if (contexts_.find(ctx) != contexts_.end()) {
      ctx->TryCancel();
    }
    mutex_->Unlock();
    usleep(1); 
  }
}

template <typename ContextT>
void ContextRegistry<ContextT>::CancelAllActiveAndWait() {
  CancelAllActive();

  {
    ScopedMutex lock(mutex_.get());
    while (!contexts_.empty()) {
      condvar_->Wait();
    }
  }
}

}  

#endif