Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 46fc4845 authored by Myles Watson's avatar Myles Watson Committed by android-build-merger
Browse files

Revert "OS: Construct Handler using Reactor" am: cad11f49 

am: b0b1639b

Change-Id: Ia7dd29b27419a3f7e61dc38e6fcbb4a11425df0f
parents 185bf911 b0b1639b

system/gd/os/alarm.h

+1 −4
Original line number Diff line number Diff line
@@ -34,9 +34,6 @@ class Alarm { 
  // Create and register a single-shot alarm on given thread

  explicit Alarm(Thread* thread);



  // Create and register a single-shot alarm with a given reactor

  explicit Alarm(Reactor* reactor);



  // Unregister this alarm from the thread and release resource

  ~Alarm();
@@ -50,7 +47,7 @@ class Alarm { 


 private:

  Closure task_;

  Reactor* reactor_;

  Thread* thread_;

  int fd_ = 0;

  Reactor::Reactable* token_;

  mutable std::mutex mutex_;

system/gd/os/handler.h

+1 −4
Original line number Diff line number Diff line
@@ -35,9 +35,6 @@ class Handler { 
  // Create and register a handler on given thread

  explicit Handler(Thread* thread);



  // Create and register a handler with a given reactor

  explicit Handler(Reactor* reactor);



  // Unregister this handler from the thread and release resource. Unhandled events will be discarded and not executed.

  ~Handler();
@@ -54,7 +51,7 @@ class Handler { 


 private:

  std::queue<Closure> tasks_;

  Reactor* reactor_;

  Thread* thread_;

  int fd_;

  Reactor::Reactable* reactable_;

  mutable std::mutex mutex_;

system/gd/os/linux_generic/alarm.cc

+3 −5
Original line number Diff line number Diff line
@@ -32,16 +32,14 @@ 
namespace bluetooth {

namespace os {



Alarm::Alarm(Reactor* reactor) : reactor_(reactor), fd_(timerfd_create(ALARM_CLOCK, 0)) {

Alarm::Alarm(Thread* thread) : thread_(thread), fd_(timerfd_create(ALARM_CLOCK, 0)) {

  ASSERT_LOG(fd_ != -1, "cannot create timerfd: %s", strerror(errno));



  token_ = reactor_->Register(fd_, [this] { on_fire(); }, nullptr);

  token_ = thread_->GetReactor()->Register(fd_, [this] { on_fire(); }, nullptr);

}



Alarm::Alarm(Thread* thread) : Alarm(thread->GetReactor()) {}



Alarm::~Alarm() {

  reactor_->Unregister(token_);

  thread_->GetReactor()->Unregister(token_);



  int close_status;

  RUN_NO_INTR(close_status = close(fd_));

system/gd/os/linux_generic/handler.cc

+3 −5
Original line number Diff line number Diff line
@@ -31,16 +31,14 @@ 
namespace bluetooth {

namespace os {



Handler::Handler(Reactor* reactor) : reactor_(reactor), fd_(eventfd(0, EFD_SEMAPHORE | EFD_NONBLOCK)) {

Handler::Handler(Thread* thread) : thread_(thread), fd_(eventfd(0, EFD_SEMAPHORE | EFD_NONBLOCK)) {

  ASSERT(fd_ != -1);



  reactable_ = reactor_->Register(fd_, [this] { this->handle_next_event(); }, nullptr);

  reactable_ = thread_->GetReactor()->Register(fd_, [this] { this->handle_next_event(); }, nullptr);

}



Handler::Handler(Thread* thread) : Handler(thread->GetReactor()) {}



Handler::~Handler() {

  reactor_->Unregister(reactable_);

  thread_->GetReactor()->Unregister(reactable_);

  reactable_ = nullptr;



  int close_status;

system/gd/os/linux_generic/queue.tpp

+5 −5
Original line number Diff line number Diff line
@@ -29,7 +29,7 @@ void Queue<T>::RegisterEnqueue(Handler* handler, EnqueueCallback callback) { 
  ASSERT(enqueue_.handler_ == nullptr);

  ASSERT(enqueue_.reactable_ == nullptr);

  enqueue_.handler_ = handler;

  enqueue_.reactable_ = enqueue_.handler_->reactor_->Register(

  enqueue_.reactable_ = enqueue_.handler_->thread_->GetReactor()->Register(

      enqueue_.reactive_semaphore_.GetFd(), [this, callback] { EnqueueCallbackInternal(callback); }, nullptr);

}
@@ -37,7 +37,7 @@ template <typename T> 
void Queue<T>::UnregisterEnqueue() {

  std::lock_guard<std::mutex> lock(mutex_);

  ASSERT(enqueue_.reactable_ != nullptr);

  enqueue_.handler_->reactor_->Unregister(enqueue_.reactable_);

  enqueue_.handler_->thread_->GetReactor()->Unregister(enqueue_.reactable_);

  enqueue_.reactable_ = nullptr;

  enqueue_.handler_ = nullptr;

}
@@ -48,15 +48,15 @@ void Queue<T>::RegisterDequeue(Handler* handler, DequeueCallback callback) { 
  ASSERT(dequeue_.handler_ == nullptr);

  ASSERT(dequeue_.reactable_ == nullptr);

  dequeue_.handler_ = handler;

  dequeue_.reactable_ =

      dequeue_.handler_->reactor_->Register(dequeue_.reactive_semaphore_.GetFd(), [callback] { callback(); }, nullptr);

  dequeue_.reactable_ = dequeue_.handler_->thread_->GetReactor()->Register(dequeue_.reactive_semaphore_.GetFd(),

                                                                           [callback] { callback(); }, nullptr);

}



template <typename T>

void Queue<T>::UnregisterDequeue() {

  std::lock_guard<std::mutex> lock(mutex_);

  ASSERT(dequeue_.reactable_ != nullptr);

  dequeue_.handler_->reactor_->Unregister(dequeue_.reactable_);

  dequeue_.handler_->thread_->GetReactor()->Unregister(dequeue_.reactable_);

  dequeue_.reactable_ = nullptr;

  dequeue_.handler_ = nullptr;

}