Karthik Ravi Shankar
6 years ago
commit
5a132b8245
179 changed files with 5373 additions and 2126 deletions
@ -1,30 +0,0 @@ |
|||||||
{ |
|
||||||
"version": "0.2.0", |
|
||||||
"configurations": [ |
|
||||||
{ |
|
||||||
"type": "node", |
|
||||||
"request": "launch", |
|
||||||
"name": "Mocha Tests", |
|
||||||
"cwd": "${workspaceRoot}", |
|
||||||
"runtimeExecutable": "${workspaceRoot}/node_modules/.bin/mocha", |
|
||||||
"windows": { |
|
||||||
"runtimeExecutable": "${workspaceRoot}/node_modules/.bin/mocha.cmd" |
|
||||||
}, |
|
||||||
"runtimeArgs": [ |
|
||||||
"-u", |
|
||||||
"tdd", |
|
||||||
"--timeout", |
|
||||||
"999999", |
|
||||||
"--colors", |
|
||||||
"${workspaceRoot}/src/node/test" |
|
||||||
], |
|
||||||
"internalConsoleOptions": "openOnSessionStart" |
|
||||||
}, |
|
||||||
{ |
|
||||||
"type": "node", |
|
||||||
"request": "attach", |
|
||||||
"name": "Attach to Process", |
|
||||||
"port": 5858 |
|
||||||
} |
|
||||||
] |
|
||||||
} |
|
||||||
File diff suppressed because it is too large
Load Diff
@ -1,152 +0,0 @@ |
|||||||
/*
|
|
||||||
* |
|
||||||
* Copyright 2017 gRPC authors. |
|
||||||
* |
|
||||||
* Licensed under the Apache License, Version 2.0 (the "License"); |
|
||||||
* you may not use this file except in compliance with the License. |
|
||||||
* You may obtain a copy of the License at |
|
||||||
* |
|
||||||
* http://www.apache.org/licenses/LICENSE-2.0
|
|
||||||
* |
|
||||||
* Unless required by applicable law or agreed to in writing, software |
|
||||||
* distributed under the License is distributed on an "AS IS" BASIS, |
|
||||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
|
||||||
* See the License for the specific language governing permissions and |
|
||||||
* limitations under the License. |
|
||||||
* |
|
||||||
*/ |
|
||||||
|
|
||||||
#include <grpc/support/port_platform.h> |
|
||||||
|
|
||||||
#include "src/core/lib/gpr/arena.h" |
|
||||||
|
|
||||||
#include <string.h> |
|
||||||
#include <new> |
|
||||||
|
|
||||||
#include <grpc/support/alloc.h> |
|
||||||
#include <grpc/support/atm.h> |
|
||||||
#include <grpc/support/log.h> |
|
||||||
#include <grpc/support/sync.h> |
|
||||||
|
|
||||||
#include "src/core/lib/gpr/alloc.h" |
|
||||||
#include "src/core/lib/gprpp/memory.h" |
|
||||||
|
|
||||||
static void* gpr_arena_malloc(size_t size) { |
|
||||||
return gpr_malloc_aligned(size, GPR_MAX_ALIGNMENT); |
|
||||||
} |
|
||||||
|
|
||||||
// Uncomment this to use a simple arena that simply allocates the
|
|
||||||
// requested amount of memory for each call to gpr_arena_alloc(). This
|
|
||||||
// effectively eliminates the efficiency gain of using an arena, but it
|
|
||||||
// may be useful for debugging purposes.
|
|
||||||
//#define SIMPLE_ARENA_FOR_DEBUGGING
|
|
||||||
#ifdef SIMPLE_ARENA_FOR_DEBUGGING |
|
||||||
|
|
||||||
struct gpr_arena { |
|
||||||
gpr_arena() { gpr_mu_init(&mu); } |
|
||||||
~gpr_arena() { |
|
||||||
gpr_mu_destroy(&mu); |
|
||||||
for (size_t i = 0; i < num_ptrs; ++i) { |
|
||||||
gpr_free_aligned(ptrs[i]); |
|
||||||
} |
|
||||||
gpr_free(ptrs); |
|
||||||
} |
|
||||||
|
|
||||||
gpr_mu mu; |
|
||||||
void** ptrs = nullptr; |
|
||||||
size_t num_ptrs = 0; |
|
||||||
}; |
|
||||||
|
|
||||||
gpr_arena* gpr_arena_create(size_t ignored_initial_size) { |
|
||||||
return grpc_core::New<gpr_arena>(); |
|
||||||
} |
|
||||||
|
|
||||||
size_t gpr_arena_destroy(gpr_arena* arena) { |
|
||||||
grpc_core::Delete(arena); |
|
||||||
return 1; // Value doesn't matter, since it won't be used.
|
|
||||||
} |
|
||||||
|
|
||||||
void* gpr_arena_alloc(gpr_arena* arena, size_t size) { |
|
||||||
gpr_mu_lock(&arena->mu); |
|
||||||
arena->ptrs = |
|
||||||
(void**)gpr_realloc(arena->ptrs, sizeof(void*) * (arena->num_ptrs + 1)); |
|
||||||
void* retval = arena->ptrs[arena->num_ptrs++] = gpr_arena_malloc(size); |
|
||||||
gpr_mu_unlock(&arena->mu); |
|
||||||
return retval; |
|
||||||
} |
|
||||||
|
|
||||||
#else // SIMPLE_ARENA_FOR_DEBUGGING
|
|
||||||
|
|
||||||
// TODO(roth): We currently assume that all callers need alignment of 16
|
|
||||||
// bytes, which may be wrong in some cases. As part of converting the
|
|
||||||
// arena API to C++, we should consider replacing gpr_arena_alloc() with a
|
|
||||||
// template that takes the type of the value being allocated, which
|
|
||||||
// would allow us to use the alignment actually needed by the caller.
|
|
||||||
|
|
||||||
typedef struct zone { |
|
||||||
zone* next = nullptr; |
|
||||||
} zone; |
|
||||||
|
|
||||||
struct gpr_arena { |
|
||||||
gpr_arena(size_t initial_size) |
|
||||||
: initial_zone_size(initial_size), last_zone(&initial_zone) { |
|
||||||
gpr_mu_init(&arena_growth_mutex); |
|
||||||
} |
|
||||||
~gpr_arena() { |
|
||||||
gpr_mu_destroy(&arena_growth_mutex); |
|
||||||
zone* z = initial_zone.next; |
|
||||||
while (z) { |
|
||||||
zone* next_z = z->next; |
|
||||||
z->~zone(); |
|
||||||
gpr_free_aligned(z); |
|
||||||
z = next_z; |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
// Keep track of the total used size. We use this in our call sizing
|
|
||||||
// historesis.
|
|
||||||
gpr_atm total_used = 0; |
|
||||||
size_t initial_zone_size; |
|
||||||
zone initial_zone; |
|
||||||
zone* last_zone; |
|
||||||
gpr_mu arena_growth_mutex; |
|
||||||
}; |
|
||||||
|
|
||||||
gpr_arena* gpr_arena_create(size_t initial_size) { |
|
||||||
initial_size = GPR_ROUND_UP_TO_ALIGNMENT_SIZE(initial_size); |
|
||||||
return new (gpr_arena_malloc( |
|
||||||
GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(gpr_arena)) + initial_size)) |
|
||||||
gpr_arena(initial_size); |
|
||||||
} |
|
||||||
|
|
||||||
size_t gpr_arena_destroy(gpr_arena* arena) { |
|
||||||
const gpr_atm size = gpr_atm_no_barrier_load(&arena->total_used); |
|
||||||
arena->~gpr_arena(); |
|
||||||
gpr_free_aligned(arena); |
|
||||||
return static_cast<size_t>(size); |
|
||||||
} |
|
||||||
|
|
||||||
void* gpr_arena_alloc(gpr_arena* arena, size_t size) { |
|
||||||
size = GPR_ROUND_UP_TO_ALIGNMENT_SIZE(size); |
|
||||||
size_t begin = gpr_atm_no_barrier_fetch_add(&arena->total_used, size); |
|
||||||
if (begin + size <= arena->initial_zone_size) { |
|
||||||
return reinterpret_cast<char*>(arena) + |
|
||||||
GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(gpr_arena)) + begin; |
|
||||||
} else { |
|
||||||
// If the allocation isn't able to end in the initial zone, create a new
|
|
||||||
// zone for this allocation, and any unused space in the initial zone is
|
|
||||||
// wasted. This overflowing and wasting is uncommon because of our arena
|
|
||||||
// sizing historesis (that is, most calls should have a large enough initial
|
|
||||||
// zone and will not need to grow the arena).
|
|
||||||
gpr_mu_lock(&arena->arena_growth_mutex); |
|
||||||
zone* z = new (gpr_arena_malloc( |
|
||||||
GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(zone)) + size)) zone(); |
|
||||||
arena->last_zone->next = z; |
|
||||||
arena->last_zone = z; |
|
||||||
gpr_mu_unlock(&arena->arena_growth_mutex); |
|
||||||
return reinterpret_cast<char*>(z) + |
|
||||||
GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(zone)); |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
#endif // SIMPLE_ARENA_FOR_DEBUGGING
|
|
||||||
@ -0,0 +1,103 @@ |
|||||||
|
/*
|
||||||
|
* |
||||||
|
* Copyright 2017 gRPC authors. |
||||||
|
* |
||||||
|
* Licensed under the Apache License, Version 2.0 (the "License"); |
||||||
|
* you may not use this file except in compliance with the License. |
||||||
|
* You may obtain a copy of the License at |
||||||
|
* |
||||||
|
* http://www.apache.org/licenses/LICENSE-2.0
|
||||||
|
* |
||||||
|
* Unless required by applicable law or agreed to in writing, software |
||||||
|
* distributed under the License is distributed on an "AS IS" BASIS, |
||||||
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
||||||
|
* See the License for the specific language governing permissions and |
||||||
|
* limitations under the License. |
||||||
|
* |
||||||
|
*/ |
||||||
|
|
||||||
|
#include <grpc/support/port_platform.h> |
||||||
|
|
||||||
|
#include "src/core/lib/gprpp/arena.h" |
||||||
|
|
||||||
|
#include <string.h> |
||||||
|
#include <new> |
||||||
|
|
||||||
|
#include <grpc/support/alloc.h> |
||||||
|
#include <grpc/support/atm.h> |
||||||
|
#include <grpc/support/log.h> |
||||||
|
#include <grpc/support/sync.h> |
||||||
|
|
||||||
|
#include "src/core/lib/gpr/alloc.h" |
||||||
|
#include "src/core/lib/gprpp/memory.h" |
||||||
|
|
||||||
|
namespace { |
||||||
|
|
||||||
|
void* ArenaStorage(size_t initial_size) { |
||||||
|
static constexpr size_t base_size = |
||||||
|
GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(grpc_core::Arena)); |
||||||
|
initial_size = GPR_ROUND_UP_TO_ALIGNMENT_SIZE(initial_size); |
||||||
|
size_t alloc_size = base_size + initial_size; |
||||||
|
static constexpr size_t alignment = |
||||||
|
(GPR_CACHELINE_SIZE > GPR_MAX_ALIGNMENT && |
||||||
|
GPR_CACHELINE_SIZE % GPR_MAX_ALIGNMENT == 0) |
||||||
|
? GPR_CACHELINE_SIZE |
||||||
|
: GPR_MAX_ALIGNMENT; |
||||||
|
return gpr_malloc_aligned(alloc_size, alignment); |
||||||
|
} |
||||||
|
|
||||||
|
} // namespace
|
||||||
|
|
||||||
|
namespace grpc_core { |
||||||
|
|
||||||
|
Arena::~Arena() { |
||||||
|
Zone* z = last_zone_; |
||||||
|
while (z) { |
||||||
|
Zone* prev_z = z->prev; |
||||||
|
z->~Zone(); |
||||||
|
gpr_free_aligned(z); |
||||||
|
z = prev_z; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
Arena* Arena::Create(size_t initial_size) { |
||||||
|
return new (ArenaStorage(initial_size)) Arena(initial_size); |
||||||
|
} |
||||||
|
|
||||||
|
Pair<Arena*, void*> Arena::CreateWithAlloc(size_t initial_size, |
||||||
|
size_t alloc_size) { |
||||||
|
static constexpr size_t base_size = |
||||||
|
GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(Arena)); |
||||||
|
auto* new_arena = |
||||||
|
new (ArenaStorage(initial_size)) Arena(initial_size, alloc_size); |
||||||
|
void* first_alloc = reinterpret_cast<char*>(new_arena) + base_size; |
||||||
|
return MakePair(new_arena, first_alloc); |
||||||
|
} |
||||||
|
|
||||||
|
size_t Arena::Destroy() { |
||||||
|
size_t size = total_used_.Load(MemoryOrder::RELAXED); |
||||||
|
this->~Arena(); |
||||||
|
gpr_free_aligned(this); |
||||||
|
return size; |
||||||
|
} |
||||||
|
|
||||||
|
void* Arena::AllocZone(size_t size) { |
||||||
|
// If the allocation isn't able to end in the initial zone, create a new
|
||||||
|
// zone for this allocation, and any unused space in the initial zone is
|
||||||
|
// wasted. This overflowing and wasting is uncommon because of our arena
|
||||||
|
// sizing hysteresis (that is, most calls should have a large enough initial
|
||||||
|
// zone and will not need to grow the arena).
|
||||||
|
static constexpr size_t zone_base_size = |
||||||
|
GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(Zone)); |
||||||
|
size_t alloc_size = zone_base_size + size; |
||||||
|
Zone* z = new (gpr_malloc_aligned(alloc_size, GPR_MAX_ALIGNMENT)) Zone(); |
||||||
|
{ |
||||||
|
gpr_spinlock_lock(&arena_growth_spinlock_); |
||||||
|
z->prev = last_zone_; |
||||||
|
last_zone_ = z; |
||||||
|
gpr_spinlock_unlock(&arena_growth_spinlock_); |
||||||
|
} |
||||||
|
return reinterpret_cast<char*>(z) + zone_base_size; |
||||||
|
} |
||||||
|
|
||||||
|
} // namespace grpc_core
|
||||||
@ -0,0 +1,121 @@ |
|||||||
|
/*
|
||||||
|
* |
||||||
|
* Copyright 2017 gRPC authors. |
||||||
|
* |
||||||
|
* Licensed under the Apache License, Version 2.0 (the "License"); |
||||||
|
* you may not use this file except in compliance with the License. |
||||||
|
* You may obtain a copy of the License at |
||||||
|
* |
||||||
|
* http://www.apache.org/licenses/LICENSE-2.0
|
||||||
|
* |
||||||
|
* Unless required by applicable law or agreed to in writing, software |
||||||
|
* distributed under the License is distributed on an "AS IS" BASIS, |
||||||
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
||||||
|
* See the License for the specific language governing permissions and |
||||||
|
* limitations under the License. |
||||||
|
* |
||||||
|
*/ |
||||||
|
|
||||||
|
// \file Arena based allocator
|
||||||
|
// Allows very fast allocation of memory, but that memory cannot be freed until
|
||||||
|
// the arena as a whole is freed
|
||||||
|
// Tracks the total memory allocated against it, so that future arenas can
|
||||||
|
// pre-allocate the right amount of memory
|
||||||
|
|
||||||
|
#ifndef GRPC_CORE_LIB_GPRPP_ARENA_H |
||||||
|
#define GRPC_CORE_LIB_GPRPP_ARENA_H |
||||||
|
|
||||||
|
#include <grpc/support/port_platform.h> |
||||||
|
|
||||||
|
#include <new> |
||||||
|
#include <utility> |
||||||
|
|
||||||
|
#include <grpc/support/alloc.h> |
||||||
|
#include <grpc/support/sync.h> |
||||||
|
|
||||||
|
#include "src/core/lib/gpr/alloc.h" |
||||||
|
#include "src/core/lib/gpr/spinlock.h" |
||||||
|
#include "src/core/lib/gprpp/atomic.h" |
||||||
|
#include "src/core/lib/gprpp/pair.h" |
||||||
|
|
||||||
|
#include <stddef.h> |
||||||
|
|
||||||
|
namespace grpc_core { |
||||||
|
|
||||||
|
class Arena { |
||||||
|
public: |
||||||
|
// Create an arena, with \a initial_size bytes in the first allocated buffer.
|
||||||
|
static Arena* Create(size_t initial_size); |
||||||
|
|
||||||
|
// Create an arena, with \a initial_size bytes in the first allocated buffer,
|
||||||
|
// and return both a void pointer to the returned arena and a void* with the
|
||||||
|
// first allocation.
|
||||||
|
static Pair<Arena*, void*> CreateWithAlloc(size_t initial_size, |
||||||
|
size_t alloc_size); |
||||||
|
|
||||||
|
// Destroy an arena, returning the total number of bytes allocated.
|
||||||
|
size_t Destroy(); |
||||||
|
// Allocate \a size bytes from the arena.
|
||||||
|
void* Alloc(size_t size) { |
||||||
|
static constexpr size_t base_size = |
||||||
|
GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(Arena)); |
||||||
|
size = GPR_ROUND_UP_TO_ALIGNMENT_SIZE(size); |
||||||
|
size_t begin = total_used_.FetchAdd(size, MemoryOrder::RELAXED); |
||||||
|
if (begin + size <= initial_zone_size_) { |
||||||
|
return reinterpret_cast<char*>(this) + base_size + begin; |
||||||
|
} else { |
||||||
|
return AllocZone(size); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// TODO(roth): We currently assume that all callers need alignment of 16
|
||||||
|
// bytes, which may be wrong in some cases. When we have time, we should
|
||||||
|
// change this to instead use the alignment of the type being allocated by
|
||||||
|
// this method.
|
||||||
|
template <typename T, typename... Args> |
||||||
|
T* New(Args&&... args) { |
||||||
|
T* t = static_cast<T*>(Alloc(sizeof(T))); |
||||||
|
new (t) T(std::forward<Args>(args)...); |
||||||
|
return t; |
||||||
|
} |
||||||
|
|
||||||
|
private: |
||||||
|
struct Zone { |
||||||
|
Zone* prev; |
||||||
|
}; |
||||||
|
|
||||||
|
// Initialize an arena.
|
||||||
|
// Parameters:
|
||||||
|
// initial_size: The initial size of the whole arena in bytes. These bytes
|
||||||
|
// are contained within 'zone 0'. If the arena user ends up requiring more
|
||||||
|
// memory than the arena contains in zone 0, subsequent zones are allocated
|
||||||
|
// on demand and maintained in a tail-linked list.
|
||||||
|
//
|
||||||
|
// initial_alloc: Optionally, construct the arena as though a call to
|
||||||
|
// Alloc() had already been made for initial_alloc bytes. This provides a
|
||||||
|
// quick optimization (avoiding an atomic fetch-add) for the common case
|
||||||
|
// where we wish to create an arena and then perform an immediate
|
||||||
|
// allocation.
|
||||||
|
explicit Arena(size_t initial_size, size_t initial_alloc = 0) |
||||||
|
: total_used_(initial_alloc), initial_zone_size_(initial_size) {} |
||||||
|
|
||||||
|
~Arena(); |
||||||
|
|
||||||
|
void* AllocZone(size_t size); |
||||||
|
|
||||||
|
// Keep track of the total used size. We use this in our call sizing
|
||||||
|
// hysteresis.
|
||||||
|
Atomic<size_t> total_used_; |
||||||
|
size_t initial_zone_size_; |
||||||
|
gpr_spinlock arena_growth_spinlock_ = GPR_SPINLOCK_STATIC_INITIALIZER; |
||||||
|
// If the initial arena allocation wasn't enough, we allocate additional zones
|
||||||
|
// in a reverse linked list. Each additional zone consists of (1) a pointer to
|
||||||
|
// the zone added before this zone (null if this is the first additional zone)
|
||||||
|
// and (2) the allocated memory. The arena itself maintains a pointer to the
|
||||||
|
// last zone; the zone list is reverse-walked during arena destruction only.
|
||||||
|
Zone* last_zone_ = nullptr; |
||||||
|
}; |
||||||
|
|
||||||
|
} // namespace grpc_core
|
||||||
|
|
||||||
|
#endif /* GRPC_CORE_LIB_GPRPP_ARENA_H */ |
||||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in new issue