/*
- * Copyright 2014 Facebook, Inc.
+ * Copyright 2015 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#define __STDC_LIMIT_MACROS
-#include "folly/io/IOBuf.h"
+#include <folly/io/IOBuf.h>
-#include "folly/Conv.h"
-#include "folly/Likely.h"
-#include "folly/Malloc.h"
-#include "folly/Memory.h"
-#include "folly/ScopeGuard.h"
-#include "folly/SpookyHashV2.h"
-#include "folly/io/Cursor.h"
+#include <folly/Conv.h>
+#include <folly/Likely.h>
+#include <folly/Malloc.h>
+#include <folly/Memory.h>
+#include <folly/ScopeGuard.h>
+#include <folly/SpookyHashV2.h>
+#include <folly/io/Cursor.h>
#include <stdexcept>
#include <assert.h>
HeapStorage hs;
SharedInfo shared;
- MaxAlign align;
+ std::max_align_t align;
};
IOBuf::SharedInfo::SharedInfo()
*this = std::move(other);
}
+IOBuf::IOBuf(const IOBuf& other) {
+ other.cloneInto(*this);
+}
+
IOBuf::IOBuf(InternalConstructor,
uintptr_t flagsAndSharedInfo,
uint8_t* buf,
return *this;
}
+IOBuf& IOBuf::operator=(const IOBuf& other) {
+ if (this != &other) {
+ *this = IOBuf(other);
+ }
+ return *this;
+}
+
bool IOBuf::empty() const {
const IOBuf* current = this;
do {
coalesceSlow();
}
+void IOBuf::makeManagedChained() {
+ assert(isChained());
+
+ IOBuf* current = this;
+ while (true) {
+ current->makeManagedOne();
+ current = current->next_;
+ if (current == this) {
+ break;
+ }
+ }
+}
+
void IOBuf::coalesceSlow() {
// coalesceSlow() should only be called if we are part of a chain of multiple
// IOBufs. The caller should have already verified this.
IOBuf* end,
size_t newTailroom) {
uint64_t newCapacity = newLength + newHeadroom + newTailroom;
- if (newCapacity > UINT32_MAX) {
- throw std::overflow_error("IOBuf chain too large to coalesce");
- }
// Allocate space for the coalesced buffer.
// We always convert to an external buffer, even if we happened to be an
return;
}
- size_t newAllocatedCapacity = goodExtBufferSize(newCapacity);
+ size_t newAllocatedCapacity = 0;
uint8_t* newBuffer = nullptr;
uint64_t newHeadroom = 0;
uint64_t oldHeadroom = headroom();
// If we have a buffer allocated with malloc and we just need more tailroom,
- // try to use realloc()/rallocm() to grow the buffer in place.
+ // try to use realloc()/xallocx() to grow the buffer in place.
SharedInfo* info = sharedInfo();
if (info && (info->freeFn == nullptr) && length_ != 0 &&
oldHeadroom >= minHeadroom) {
+ size_t headSlack = oldHeadroom - minHeadroom;
+ newAllocatedCapacity = goodExtBufferSize(newCapacity + headSlack);
if (usingJEMalloc()) {
- size_t headSlack = oldHeadroom - minHeadroom;
// We assume that tailroom is more useful and more important than
- // headroom (not least because realloc / rallocm allow us to grow the
+ // headroom (not least because realloc / xallocx allow us to grow the
// buffer at the tail, but not at the head) So, if we have more headroom
// than we need, we consider that "wasted". We arbitrarily define "too
// much" headroom to be 25% of the capacity.
size_t allocatedCapacity = capacity() + sizeof(SharedInfo);
void* p = buf_;
if (allocatedCapacity >= jemallocMinInPlaceExpandable) {
- // rallocm can write to its 2nd arg even if it returns
- // ALLOCM_ERR_NOT_MOVED. So, we pass a temporary to its 2nd arg and
- // update newAllocatedCapacity only on success.
- size_t allocatedSize;
- int r = rallocm(&p, &allocatedSize, newAllocatedCapacity,
- 0, ALLOCM_NO_MOVE);
- if (r == ALLOCM_SUCCESS) {
+ if (xallocx(p, newAllocatedCapacity, 0, 0) == newAllocatedCapacity) {
newBuffer = static_cast<uint8_t*>(p);
newHeadroom = oldHeadroom;
- newAllocatedCapacity = allocatedSize;
- } else if (r == ALLOCM_ERR_OOM) {
- // shouldn't happen as we don't actually allocate new memory
- // (due to ALLOCM_NO_MOVE)
- throw std::bad_alloc();
}
- // if ALLOCM_ERR_NOT_MOVED, do nothing, fall back to
- // malloc/memcpy/free
+ // if xallocx failed, do nothing, fall back to malloc/memcpy/free
}
}
} else { // Not using jemalloc
// None of the previous reallocation strategies worked (or we're using
// an internal buffer). malloc/copy/free.
if (newBuffer == nullptr) {
+ newAllocatedCapacity = goodExtBufferSize(newCapacity);
void* p = malloc(newAllocatedCapacity);
if (UNLIKELY(p == nullptr)) {
throw std::bad_alloc();
folly::fbvector<struct iovec> IOBuf::getIov() const {
folly::fbvector<struct iovec> iov;
iov.reserve(countChainElements());
+ appendToIov(&iov);
+ return iov;
+}
+
+void IOBuf::appendToIov(folly::fbvector<struct iovec>* iov) const {
IOBuf const* p = this;
do {
// some code can get confused by empty iovs, so skip them
if (p->length() > 0) {
- iov.push_back({(void*)p->data(), folly::to<size_t>(p->length())});
+ iov->push_back({(void*)p->data(), folly::to<size_t>(p->length())});
}
p = p->next();
} while (p != this);
- return iov;
+}
+
+size_t IOBuf::fillIov(struct iovec* iov, size_t len) const {
+ IOBuf const* p = this;
+ size_t i = 0;
+ while (i < len) {
+ // some code can get confused by empty iovs, so skip them
+ if (p->length() > 0) {
+ iov[i].iov_base = const_cast<uint8_t*>(p->data());
+ iov[i].iov_len = p->length();
+ i++;
+ }
+ p = p->next();
+ if (p == this) {
+ return i;
+ }
+ }
+ return 0;
}
size_t IOBufHash::operator()(const IOBuf& buf) const {