src/mem_node.cc

   1 /*
   2  * Copyright (C) 1996-2023 The Squid Software Foundation and contributors
   3  *
   4  * Squid software is distributed under GPLv2+ license and includes
   5  * contributions from numerous individuals and organizations.
   6  * Please see the COPYING and CONTRIBUTORS files for details.
   7  */
   8
   9 /* DEBUG: section 19    Store Memory Primitives */
  10
  11 #include "squid.h"
  12 #include "mem/Pool.h"
  13 #include "mem_node.h"
  14
  15 #include <cstddef>
  16 #include <type_traits>
  17
  18 static ptrdiff_t makeMemNodeDataOffset();
  19
  20 static ptrdiff_t _mem_node_data_offset = makeMemNodeDataOffset();
  21
  22 /*
  23  * Calculate the offset between the start of a mem_node and
  24  * its 'data' member
  25  */
  26 static ptrdiff_t
  27 makeMemNodeDataOffset()
  28 {
  29     static_assert(std::is_standard_layout<mem_node>::value, "offsetof(mem_node) is unconditionally supported");
  30     return ptrdiff_t(offsetof(mem_node, data));
  31 }
  32
  33 /*
  34  * This is the callback when storeIOWrite() is done.  We need to
  35  * clear the write_pending flag for the mem_node.  First we have
  36  * to calculate the start of the mem_node based on the character
  37  * buffer that we wrote.  ick.
  38  */
  39 void
  40 memNodeWriteComplete(void* d)
  41 {
  42     mem_node* n = (mem_node*)((char*)d - _mem_node_data_offset);
  43     assert(n->write_pending);
  44     n->write_pending = false;
  45 }
  46
  47 mem_node::mem_node(int64_t offset) :
  48     nodeBuffer(0,offset,data),
  49     write_pending(false)
  50 {
  51     *data = 0;
  52 }
  53
  54 mem_node::~mem_node()
  55 {}
  56
  57 size_t
  58 mem_node::InUseCount()
  59 {
  60     return Pool().inUseCount();
  61 }
  62
  63 size_t
  64 mem_node::StoreMemSize()
  65 {
  66     return InUseCount() * SM_PAGE_SIZE;
  67 }
  68
  69 int64_t
  70 mem_node::start() const
  71 {
  72     assert (nodeBuffer.offset >= 0);
  73     return nodeBuffer.offset;
  74 }
  75
  76 int64_t
  77 mem_node::end() const
  78 {
  79     return nodeBuffer.offset + nodeBuffer.length;
  80 }
  81
  82 Range<int64_t>
  83 mem_node::dataRange() const
  84 {
  85     return Range<int64_t> (start(), end());
  86 }
  87
  88 size_t
  89 mem_node::space() const
  90 {
  91     return SM_PAGE_SIZE - nodeBuffer.length;
  92 }
  93
  94 bool
  95 mem_node::contains (int64_t const &location) const
  96 {
  97     if (start() <= location && end() > location)
  98         return true;
  99
 100     return false;
 101 }
 102
 103 /* nodes can not be sparse */
 104 bool
 105 mem_node::canAccept (int64_t const &location) const
 106 {
 107     if (location == end() && space() > 0)
 108         return true;
 109
 110     return false;
 111 }
 112
 113 bool
 114 mem_node::operator < (mem_node const & rhs) const
 115 {
 116     return start() < rhs.start();
 117 }
 118