Method alloc

src/backend/common/DefaultMemoryManager.cpp:158–225

}

void *DefaultMemoryManager::alloc(bool user_lock, const unsigned ndims,
                                  dim_t *dims, const unsigned element_size) {
    size_t bytes = element_size;
    for (unsigned i = 0; i < ndims; ++i) { bytes *= dims[i]; }

    void *ptr          = nullptr;
    size_t alloc_bytes = this->debug_mode
                             ? bytes
                             : (divup(bytes, mem_step_size) * mem_step_size);

    if (bytes > 0) {
        memory_info &current = this->getCurrentMemoryInfo();
        locked_info info     = {!user_lock, user_lock, alloc_bytes};

        // There is no memory cache in debug mode
        if (!this->debug_mode) {
            // FIXME: Add better checks for garbage collection
            // Perhaps look at total memory available as a metric
            if (current.lock_bytes >= current.max_bytes ||
                current.total_buffers >= this->max_buffers) {
                AF_TRACE(
                    "Running GC: current.lock_bytes({}) >= "
                    "current.max_bytes({}) || current.total_buffers({}) >= "
                    "this->max_buffers({})\n",
                    current.lock_bytes, current.max_bytes,
                    current.total_buffers, this->max_buffers);

                this->signalMemoryCleanup();
            }

            lock_guard_t lock(this->memory_mutex);
            auto free_buffer_iter = current.free_map.find(alloc_bytes);
            if (free_buffer_iter != current.free_map.end() &&
                !free_buffer_iter->second.empty()) {
                // Delete existing buffer info and underlying event
                // Set to existing in from free map
                vector<void *> &free_buffer_vector = free_buffer_iter->second;
                ptr                                = free_buffer_vector.back();
                free_buffer_vector.pop_back();
                current.locked_map[ptr] = info;
                current.lock_bytes += alloc_bytes;
                current.lock_buffers++;
            }
        }

        // Only comes here if buffer size not found or in debug mode
        if (ptr == nullptr) {
            // Perform garbage collection if memory can not be allocated
            try {
                ptr = this->nativeAlloc(alloc_bytes);
            } catch (const AfError &ex) {
                // If out of memory, run garbage collect and try again
                if (ex.getError() != AF_ERR_NO_MEM) { throw; }
                this->signalMemoryCleanup();
                ptr = this->nativeAlloc(alloc_bytes);
            }
            lock_guard_t lock(this->memory_mutex);
            // Increment these two only when it succeeds to come here.