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

Commit cda9f07b authored by Hansong Zhang's avatar Hansong Zhang
Browse files

L2CAP: Minor clean up for scheduler and mtu 

* After dequeuing a SDU from channel queue end, unregister dequeue,
until that SDU has been sent to link queue end. Since we only support
basic mode for now, we directly convert a SDU to PDU.
* Cleaned up docs.
* Removed unused method in Scheduler interface.
* Removed unnecessary Mtu constants.

Test: run_cert.sh
Bug: 144375926
Change-Id: I50e6d383dac911ccc2010857f6447af9c59a9562
parent 9f011f58

system/gd/l2cap/internal/scheduler.h

+4 −9
Original line number Diff line number Diff line
@@ -29,9 +29,10 @@ namespace internal { 
/**

 * Handle the scheduling of packets through the l2cap stack.

 * For each attached channel, dequeue its outgoing packets and enqueue it to the given LinkQueueUpEnd, according to some

 * policy (cid). Dequeue incoming packets from LinkQueueUpEnd, and enqueue it to ChannelQueueDownEnd. Note: If a channel

 * cannot dequeue from ChannelQueueDownEnd so that the buffer for incoming packet is full, further incoming packets will

 * be dropped.

 * policy (cid).

 *

 * Note: If a channel cannot dequeue from ChannelQueueDownEnd so that the buffer for incoming packet is full, further

 * incoming packets will be dropped.

 */

class Scheduler {

 public:
@@ -41,7 +42,6 @@ class Scheduler { 
  using LowerEnqueue = UpperDequeue;

  using LowerDequeue = UpperEnqueue;

  using LowerQueueUpEnd = common::BidiQueueEnd<LowerEnqueue, LowerDequeue>;

  using DemuxPolicy = common::Callback<Cid(const UpperEnqueue&)>;



  /**

   * Attach the channel with the specified ChannelQueueDownEnd into the scheduler.
@@ -59,11 +59,6 @@ class Scheduler { 
   */

  virtual void DetachChannel(Cid cid) {}



  /**

   * Return the lower queue up end, which can be used to enqueue or dequeue.

   */

  virtual LowerQueueUpEnd* GetLowerQueueUpEnd() const = 0;



  virtual ~Scheduler() = default;

};

system/gd/l2cap/internal/scheduler_fifo.cc

+15 −11
Original line number Diff line number Diff line
@@ -22,6 +22,11 @@ namespace bluetooth { 
namespace l2cap {

namespace internal {



Fifo::Fifo(LowerQueueUpEnd* link_queue_up_end, os::Handler* handler)

    : link_queue_up_end_(link_queue_up_end), handler_(handler) {

  ASSERT(link_queue_up_end_ != nullptr && handler_ != nullptr);

}



Fifo::~Fifo() {

  channel_queue_end_map_.clear();

  if (link_queue_enqueue_registered_) {
@@ -44,18 +49,17 @@ std::unique_ptr<Fifo::UpperDequeue> Fifo::link_queue_enqueue_callback() { 
  ASSERT(!next_to_dequeue_.empty());

  auto channel_id = next_to_dequeue_.front();

  next_to_dequeue_.pop();

  auto& dequeue_buffer = channel_queue_end_map_.find(channel_id)->second.dequeue_buffer_;

  auto packet = std::move(dequeue_buffer.front());

  dequeue_buffer.pop();

  if (dequeue_buffer.size() < ChannelQueueEndAndBuffer::kBufferSize) {

  auto& pdu_buffer = channel_queue_end_map_.find(channel_id)->second.pdu_buffer_;

  auto packet = std::move(pdu_buffer.front());

  pdu_buffer.pop();

  if (pdu_buffer.empty()) {

    channel_queue_end_map_.find(channel_id)->second.try_register_dequeue();

  }

  if (next_to_dequeue_.empty()) {

    link_queue_up_end_->UnregisterEnqueue();

    link_queue_enqueue_registered_ = false;

  }

  Cid remote_channel_id = channel_queue_end_map_.find(channel_id)->second.remote_channel_id_;

  return BasicFrameBuilder::Create(remote_channel_id, std::move(packet));

  return packet;

}



void Fifo::try_register_link_queue_enqueue() {
@@ -79,11 +83,11 @@ void Fifo::ChannelQueueEndAndBuffer::try_register_dequeue() { 
void Fifo::ChannelQueueEndAndBuffer::dequeue_callback() {

  auto packet = queue_end_->TryDequeue();

  ASSERT(packet != nullptr);

  dequeue_buffer_.emplace(std::move(packet));

  if (dequeue_buffer_.size() >= kBufferSize) {

  // TODO(hsz): Construct PDU(s) according to channel mode.

  auto pdu = BasicFrameBuilder::Create(remote_channel_id_, std::move(packet));

  pdu_buffer_.emplace(std::move(pdu));

  queue_end_->UnregisterDequeue();

  is_dequeue_registered_ = false;

  }

  scheduler_->next_to_dequeue_.push(channel_id_);

  scheduler_->try_register_link_queue_enqueue();

}

system/gd/l2cap/internal/scheduler_fifo.h

+4 −12
Original line number Diff line number Diff line
@@ -34,17 +34,10 @@ namespace internal { 


class Fifo : public Scheduler {

 public:

  Fifo(LowerQueueUpEnd* link_queue_up_end, os::Handler* handler)

      : link_queue_up_end_(link_queue_up_end), handler_(handler) {

    ASSERT(link_queue_up_end_ != nullptr && handler_ != nullptr);

  }



  Fifo(LowerQueueUpEnd* link_queue_up_end, os::Handler* handler);

  ~Fifo() override;

  void AttachChannel(Cid cid, UpperQueueDownEnd* channel_down_end, Cid remote_cid) override;

  void DetachChannel(Cid cid) override;

  LowerQueueUpEnd* GetLowerQueueUpEnd() const override {

    return link_queue_up_end_;

  }



 private:

  LowerQueueUpEnd* link_queue_up_end_;
@@ -59,11 +52,10 @@ class Fifo : public Scheduler { 
    }

    os::Handler* handler_;

    UpperQueueDownEnd* queue_end_;

    constexpr static int kBufferSize = 1;

    std::queue<std::unique_ptr<UpperDequeue>> dequeue_buffer_;

    std::queue<std::unique_ptr<UpperDequeue>> pdu_buffer_;

    Fifo* scheduler_;

    Cid channel_id_;

    Cid remote_channel_id_;

    const Cid channel_id_;

    const Cid remote_channel_id_;

    bool is_dequeue_registered_ = false;



    void try_register_dequeue();

system/gd/l2cap/internal/scheduler_mock.h

+0 −1
Original line number Diff line number Diff line
@@ -31,7 +31,6 @@ class MockScheduler : public Scheduler { 
 public:

  MOCK_METHOD(void, AttachChannel, (Cid cid, UpperQueueDownEnd* channel_down_end, Cid remote_cid), (override));

  MOCK_METHOD(void, DetachChannel, (Cid cid), (override));

  MOCK_METHOD(LowerQueueUpEnd*, GetLowerQueueUpEnd, (), (override, const));

};



}  // namespace testing

system/gd/l2cap/mtu.h

+1 −3
Original line number Diff line number Diff line
@@ -22,11 +22,9 @@ namespace l2cap { 


using Mtu = uint16_t;



constexpr Mtu kDefaultMinimumClassicMtu = 48;

constexpr Mtu kDefaultMinimumLeMtu = 23;

constexpr Mtu kMinimumClassicMtu = 48;

constexpr Mtu kDefaultClassicMtu = 672;

constexpr Mtu kMinimumLeMtu = 23;

constexpr Mtu kDefaultClassicMtu = 672;



}  // namespace l2cap

}  // namespace bluetooth