FM / arrow

/usr/local/lib64/python3.6/site-packages/pyarrow/include/arrow/

/usr/local/lib64/python3.6/site-packages/pyarrow/include/arrow

Name	Size	Mode	Actions
adapters/	-	0755	rm
array/	-	0755	rm
c/	-	0755	rm
compute/	-	0755	rm
csv/	-	0755	rm
dataset/	-	0755	rm
filesystem/	-	0755	rm
flight/	-	0755	rm
io/	-	0755	rm
ipc/	-	0755	rm
json/	-	0755	rm
python/	-	0755	rm
tensor/	-	0755	rm
testing/	-	0755	rm
util/	-	0755	rm
vendored/	-	0755	rm
api.h	2290	0644	edit dl rm
array.h	1822	0644	edit dl rm
buffer.h	19493	0644	edit dl rm
buffer_builder.h	16430	0644	edit dl rm
builder.h	1481	0644	edit dl rm
chunked_array.h	9361	0644	edit dl rm
compare.h	5165	0644	edit dl rm
config.h	2267	0644	edit dl rm
datum.h	8980	0644	edit dl rm
device.h	8771	0644	edit dl rm
extension_type.h	6284	0644	edit dl rm
memory_pool.h	6294	0644	edit dl rm
memory_pool_test.h	2694	0644	edit dl rm
pch.h	1286	0644	edit dl rm
pretty_print.h	4182	0644	edit dl rm
record_batch.h	9398	0644	edit dl rm
result.h	17845	0644	edit dl rm
scalar.h	21124	0644	edit dl rm
sparse_tensor.h	25205	0644	edit dl rm
status.h	15552	0644	edit dl rm
stl.h	18297	0644	edit dl rm
stl_allocator.h	4614	0644	edit dl rm
stl_iterator.h	4583	0644	edit dl rm
table.h	11313	0644	edit dl rm
table_builder.h	3924	0644	edit dl rm
tensor.h	8913	0644	edit dl rm
type.h	72157	0644	edit dl rm
type_fwd.h	18243	0644	edit dl rm
type_traits.h	32600	0644	edit dl rm
visitor.h	6966	0644	edit dl rm
visitor_inline.h	16429	0644	edit dl rm

Edit: /usr/local/lib64/python3.6/site-packages/pyarrow/include/arrow/memory_pool_test.h (2694B)

// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you 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.

#pragma once

#include <algorithm>
#include <cstddef>
#include <cstdint>
#include <limits>

#include <gtest/gtest.h>

#include "arrow/memory_pool.h"
#include "arrow/status.h"
#include "arrow/testing/gtest_util.h"

namespace arrow {

class TestMemoryPoolBase : public ::testing::Test {
 public:
  virtual ::arrow::MemoryPool* memory_pool() = 0;

void TestMemoryTracking() {
    auto pool = memory_pool();

uint8_t* data;
    ASSERT_OK(pool->Allocate(100, &data));
    EXPECT_EQ(static_cast<uint64_t>(0), reinterpret_cast<uint64_t>(data) % 64);
    ASSERT_EQ(100, pool->bytes_allocated());

uint8_t* data2;
    ASSERT_OK(pool->Allocate(27, &data2));
    EXPECT_EQ(static_cast<uint64_t>(0), reinterpret_cast<uint64_t>(data2) % 64);
    ASSERT_EQ(127, pool->bytes_allocated());

pool->Free(data, 100);
    ASSERT_EQ(27, pool->bytes_allocated());
    pool->Free(data2, 27);
    ASSERT_EQ(0, pool->bytes_allocated());
  }

void TestOOM() {
    auto pool = memory_pool();

uint8_t* data;
    int64_t to_alloc = std::min<uint64_t>(std::numeric_limits<int64_t>::max(),
                                          std::numeric_limits<size_t>::max());
    // subtract 63 to prevent overflow after the size is aligned
    to_alloc -= 63;
    ASSERT_RAISES(OutOfMemory, pool->Allocate(to_alloc, &data));
  }

void TestReallocate() {
    auto pool = memory_pool();

uint8_t* data;
    ASSERT_OK(pool->Allocate(10, &data));
    ASSERT_EQ(10, pool->bytes_allocated());
    data[0] = 35;
    data[9] = 12;

// Expand
    ASSERT_OK(pool->Reallocate(10, 20, &data));
    ASSERT_EQ(data[9], 12);
    ASSERT_EQ(20, pool->bytes_allocated());

// Shrink
    ASSERT_OK(pool->Reallocate(20, 5, &data));
    ASSERT_EQ(data[0], 35);
    ASSERT_EQ(5, pool->bytes_allocated());

// Free
    pool->Free(data, 5);
    ASSERT_EQ(0, pool->bytes_allocated());
  }
};

}  // namespace arrow

cmd: