Changeset 176398 in webkit


Ignore:
Timestamp:
Nov 20, 2014 9:32:04 AM (9 years ago)
Author:
Antti Koivisto
Message:

Remove alignment code from cache coders
​https://bugs.webkit.org/show_bug.cgi?id=138927

Reviewed by Anders Carlsson.

Alignment code doesn't do anything useful, wastes space and produces wrong results
if the encoder and decoder buffers don't have the same 8-byte alignment.

  • NetworkProcess/cache/NetworkCacheDecoder.cpp:

(WebKit::NetworkCacheDecoder::NetworkCacheDecoder):
(WebKit::NetworkCacheDecoder::bufferIsLargeEnoughToContain):
(WebKit::NetworkCacheDecoder::decodeFixedLengthData):
(WebKit::NetworkCacheDecoder::decodeNumber):
(WebKit::roundUpToAlignment): Deleted.
(WebKit::alignedBufferIsLargeEnoughToContain): Deleted.
(WebKit::NetworkCacheDecoder::alignBufferPosition): Deleted.

  • NetworkProcess/cache/NetworkCacheDecoder.h:

(WebKit::NetworkCacheDecoder::currentOffset):
(WebKit::NetworkCacheDecoder::isInvalid):
(WebKit::NetworkCacheDecoder::markInvalid):
(WebKit::NetworkCacheDecoder::bufferIsLargeEnoughToContain):

  • NetworkProcess/cache/NetworkCacheEncoder.cpp:

(WebKit::NetworkCacheEncoder::grow):
(WebKit::NetworkCacheEncoder::encodeFixedLengthData):
(WebKit::NetworkCacheEncoder::encodeNumber):
(WebKit::roundUpToAlignment): Deleted.

  • NetworkProcess/cache/NetworkCacheEncoder.h:
Location:
trunk/Source/WebKit2
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebKit2/ChangeLog

    r176385 r176398  
     12014-11-20  Antti Koivisto  <antti@apple.com>
     2
     3        Remove alignment code from cache coders
     4        https://bugs.webkit.org/show_bug.cgi?id=138927
     5
     6        Reviewed by Anders Carlsson.
     7
     8        Alignment code doesn't do anything useful, wastes space and produces wrong results
     9        if the encoder and decoder buffers don't have the same 8-byte alignment.
     10
     11        * NetworkProcess/cache/NetworkCacheDecoder.cpp:
     12        (WebKit::NetworkCacheDecoder::NetworkCacheDecoder):
     13        (WebKit::NetworkCacheDecoder::bufferIsLargeEnoughToContain):
     14        (WebKit::NetworkCacheDecoder::decodeFixedLengthData):
     15        (WebKit::NetworkCacheDecoder::decodeNumber):
     16        (WebKit::roundUpToAlignment): Deleted.
     17        (WebKit::alignedBufferIsLargeEnoughToContain): Deleted.
     18        (WebKit::NetworkCacheDecoder::alignBufferPosition): Deleted.
     19        * NetworkProcess/cache/NetworkCacheDecoder.h:
     20        (WebKit::NetworkCacheDecoder::currentOffset):
     21        (WebKit::NetworkCacheDecoder::isInvalid):
     22        (WebKit::NetworkCacheDecoder::markInvalid):
     23        (WebKit::NetworkCacheDecoder::bufferIsLargeEnoughToContain):
     24        * NetworkProcess/cache/NetworkCacheEncoder.cpp:
     25        (WebKit::NetworkCacheEncoder::grow):
     26        (WebKit::NetworkCacheEncoder::encodeFixedLengthData):
     27        (WebKit::NetworkCacheEncoder::encodeNumber):
     28        (WebKit::roundUpToAlignment): Deleted.
     29        * NetworkProcess/cache/NetworkCacheEncoder.h:
     30
    1312014-11-20  Csaba Osztrogonác  <ossy@webkit.org>
    232

  • trunk/Source/WebKit2/NetworkProcess/cache/NetworkCacheDecoder.cpp

    r175748 r176398  
    3535NetworkCacheDecoder::NetworkCacheDecoder(const uint8_t* buffer, size_t bufferSize)
    3636    : m_buffer(buffer)
    37     , m_bufferPos(buffer)
     37    , m_bufferPosition(buffer)
    3838    , m_bufferEnd(buffer + bufferSize)
    3939    , m_checksum(0)
    … …  
    4545}
    4646
    47 static inline uint8_t* roundUpToAlignment(const uint8_t* ptr, unsigned alignment)
     47bool NetworkCacheDecoder::bufferIsLargeEnoughToContain(size_t size) const
    4848{
    49     // Assert that the alignment is a power of 2.
    50     ASSERT(alignment && !(alignment & (alignment - 1)));
    51 
    52     uintptr_t alignmentMask = alignment - 1;
    53     return reinterpret_cast<uint8_t*>((reinterpret_cast<uintptr_t>(ptr) + alignmentMask) & ~alignmentMask);
     49    return m_bufferPosition + size <= m_bufferEnd;
    5450}
    5551
    56 static inline bool alignedBufferIsLargeEnoughToContain(const uint8_t* alignedPosition, const uint8_t* bufferEnd, size_t size)
     52bool NetworkCacheDecoder::decodeFixedLengthData(uint8_t* data, size_t size)
    5753{
    58     return bufferEnd >= alignedPosition && static_cast<size_t>(bufferEnd - alignedPosition) >= size;
    59 }
    60 
    61 bool NetworkCacheDecoder::alignBufferPosition(unsigned alignment, size_t size)
    62 {
    63     uint8_t* alignedPosition = roundUpToAlignment(m_bufferPos, alignment);
    64     if (!alignedBufferIsLargeEnoughToContain(alignedPosition, m_bufferEnd, size)) {
    65         // We've walked off the end of this buffer.
    66         markInvalid();
    67         return false;
    68     }
    69    
    70     m_bufferPos = alignedPosition;
    71     return true;
    72 }
    73 
    74 bool NetworkCacheDecoder::bufferIsLargeEnoughToContain(unsigned alignment, size_t size) const
    75 {
    76     return alignedBufferIsLargeEnoughToContain(roundUpToAlignment(m_bufferPos, alignment), m_bufferEnd, size);
    77 }
    78 
    79 bool NetworkCacheDecoder::decodeFixedLengthData(uint8_t* data, size_t size, unsigned alignment)
    80 {
    81     if (!alignBufferPosition(alignment, size))
     54    if (!bufferIsLargeEnoughToContain(size))
    8255        return false;
    8356
    84     memcpy(data, m_bufferPos, size);
    85     m_bufferPos += size;
     57    memcpy(data, m_bufferPosition, size);
     58    m_bufferPosition += size;
    8659
    8760    NetworkCacheEncoder::updateChecksumForData(m_checksum, data, size);
    … …  
    9265bool NetworkCacheDecoder::decodeNumber(Type& value)
    9366{
    94     if (!alignBufferPosition(sizeof(value), sizeof(value)))
     67    if (!bufferIsLargeEnoughToContain(sizeof(value)))
    9568        return false;
    9669
    97     memcpy(&value, m_bufferPos, sizeof(value));
    98     m_bufferPos += sizeof(Type);
     70    memcpy(&value, m_bufferPosition, sizeof(value));
     71    m_bufferPosition += sizeof(Type);
    9972
    10073    NetworkCacheEncoder::updateChecksumForNumber(m_checksum, value);

  • trunk/Source/WebKit2/NetworkProcess/cache/NetworkCacheDecoder.h

    r175748 r176398  
    4040
    4141    size_t length() const { return m_bufferEnd - m_buffer; }
    42     size_t currentOffset() const { return m_bufferPos - m_buffer; }
     42    size_t currentOffset() const { return m_bufferPosition - m_buffer; }
    4343
    44     bool isInvalid() const { return m_bufferPos > m_bufferEnd; }
    45     void markInvalid() { m_bufferPos = m_bufferEnd + 1; }
     44    bool isInvalid() const { return m_bufferPosition > m_bufferEnd; }
     45    void markInvalid() { m_bufferPosition = m_bufferEnd + 1; }
    4646
    4747    bool verifyChecksum();
    4848
    49     bool decodeFixedLengthData(uint8_t*, size_t, unsigned alignment);
     49    bool decodeFixedLengthData(uint8_t*, size_t);
    5050
    5151    bool decode(bool&);
    … …  
    8484            return false;
    8585
    86         return bufferIsLargeEnoughToContain(alignof(T), numElements * sizeof(T));
     86        return bufferIsLargeEnoughToContain(numElements * sizeof(T));
    8787    }
    8888
    8989private:
    90     bool alignBufferPosition(unsigned alignment, size_t);
    91     bool bufferIsLargeEnoughToContain(unsigned alignment, size_t) const;
     90    bool bufferIsLargeEnoughToContain(size_t) const;
    9291    template<typename Type> bool decodeNumber(Type&);
    9392
    9493    const uint8_t* m_buffer;
    95     const uint8_t* m_bufferPos;
     94    const uint8_t* m_bufferPosition;
    9695    const uint8_t* m_bufferEnd;
    9796

  • trunk/Source/WebKit2/NetworkProcess/cache/NetworkCacheEncoder.cpp

    r175748 r176398  
    4040}
    4141
    42 static inline size_t roundUpToAlignment(size_t value, unsigned alignment)
     42uint8_t* NetworkCacheEncoder::grow(size_t size)
    4343{
    44     return ((value + alignment - 1) / alignment) * alignment;
    45 }
    46 
    47 uint8_t* NetworkCacheEncoder::grow(unsigned alignment, size_t size)
    48 {
    49     size_t alignedSize = roundUpToAlignment(m_buffer.size(), alignment);
    50 
    51     m_buffer.grow(alignedSize + size);
    52    
    53     return m_buffer.data() + alignedSize;
     44    uint8_t* position = m_buffer.data() + m_buffer.size();
     45    m_buffer.grow(m_buffer.size() + size);
     46    return position;
    5447}
    5548
    … …  
    6255}
    6356
    64 void NetworkCacheEncoder::encodeFixedLengthData(const uint8_t* data, size_t size, unsigned alignment)
     57void NetworkCacheEncoder::encodeFixedLengthData(const uint8_t* data, size_t size)
    6558{
    66     ASSERT(!(reinterpret_cast<uintptr_t>(data) % alignment));
    67 
    6859    updateChecksumForData(m_checksum, data, size);
    6960
    70     uint8_t* buffer = grow(alignment, size);
     61    uint8_t* buffer = grow(size);
    7162    memcpy(buffer, data, size);
    7263}
    … …  
    7566void NetworkCacheEncoder::encodeNumber(Type value)
    7667{
    77     uint8_t* buffer = grow(sizeof(Type), sizeof(Type));
    78 
    7968    NetworkCacheEncoder::updateChecksumForNumber(m_checksum, value);
    8069
     70    uint8_t* buffer = grow(sizeof(Type));
    8171    memcpy(buffer, &value, sizeof(Type));
    8272}

  • trunk/Source/WebKit2/NetworkProcess/cache/NetworkCacheEncoder.h

    r175748 r176398  
    4646
    4747    void encodeChecksum();
    48     void encodeFixedLengthData(const uint8_t*, size_t, unsigned alignment);
     48    void encodeFixedLengthData(const uint8_t*, size_t);
    4949
    5050    template<typename T> void encodeEnum(T t)
    … …  
    8585    template<typename Type> void encodeNumber(Type);
    8686
    87     uint8_t* grow(unsigned alignment, size_t);
     87    uint8_t* grow(size_t);
    8888
    8989    template <typename Type> struct Salt;
Note: See TracChangeset for help on using the changeset viewer.