OmniSciDB  471d68cefb
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
anonymous_namespace{ArrowResultSetConverter.cpp} Namespace Reference

Classes

class  ResultSetBuffer
 
class  null_type
 
struct  null_type< TYPE, std::enable_if_t< std::is_integral< TYPE >::value > >
 
struct  null_type< TYPE, std::enable_if_t< std::is_floating_point< TYPE >::value > >
 

Typedefs

template<typename TYPE >
using null_type_t = typename null_type< TYPE >::type
 

Functions

SQLTypes get_dict_index_type (const SQLTypeInfo &ti)
 
SQLTypes get_physical_type (const SQLTypeInfo &ti)
 
template<typename TYPE , typename VALUE_ARRAY_TYPE >
void create_or_append_value (const ScalarTargetValue &val_cty, std::shared_ptr< ValueArray > &values, const size_t max_size)
 
template<typename TYPE >
void create_or_append_validity (const ScalarTargetValue &value, const SQLTypeInfo &col_type, std::shared_ptr< std::vector< bool >> &null_bitmap, const size_t max_size)
 
template<typename C_TYPE , typename ARROW_TYPE = typename arrow::CTypeTraits<C_TYPE>::ArrowType>
void convert_column (ResultSetPtr result, size_t col, size_t entry_count, std::shared_ptr< arrow::Array > &out)
 
std::pair< key_t, void * > get_shm (size_t shmsz)
 
std::pair< key_t,
std::shared_ptr< arrow::Buffer > > 
get_shm_buffer (size_t size)
 
std::shared_ptr< arrow::DataType > get_arrow_type (const SQLTypeInfo &sql_type, const ExecutorDeviceType device_type)
 
template<typename BUILDER_TYPE , typename VALUE_ARRAY_TYPE >
void appendToColumnBuilder (ArrowResultSetConverter::ColumnBuilder &column_builder, const ValueArray &values, const std::shared_ptr< std::vector< bool >> &is_valid)
 
template<>
void appendToColumnBuilder< arrow::Decimal128Builder, int64_t > (ArrowResultSetConverter::ColumnBuilder &column_builder, const ValueArray &values, const std::shared_ptr< std::vector< bool >> &is_valid)
 
template<>
void appendToColumnBuilder< arrow::StringDictionary32Builder, int32_t > (ArrowResultSetConverter::ColumnBuilder &column_builder, const ValueArray &values, const std::shared_ptr< std::vector< bool >> &is_valid)
 

Typedef Documentation

template<typename TYPE >
using anonymous_namespace{ArrowResultSetConverter.cpp}::null_type_t = typedef typename null_type<TYPE>::type

Definition at line 176 of file ArrowResultSetConverter.cpp.

Function Documentation

template<typename BUILDER_TYPE , typename VALUE_ARRAY_TYPE >
void anonymous_namespace{ArrowResultSetConverter.cpp}::appendToColumnBuilder ( ArrowResultSetConverter::ColumnBuilder column_builder,
const ValueArray values,
const std::shared_ptr< std::vector< bool >> &  is_valid 
)

Definition at line 1099 of file ArrowResultSetConverter.cpp.

References ARROW_THROW_NOT_OK, ArrowResultSetConverter::ColumnBuilder::builder, CHECK, ArrowResultSetConverter::ColumnBuilder::field, DateConverters::get_epoch_days_from_seconds(), and kMilliSecsPerSec.

1101  {
1102  static_assert(!std::is_same<BUILDER_TYPE, arrow::StringDictionary32Builder>::value,
1103  "Dictionary encoded string builder requires function specialization.");
1104 
1105  std::vector<VALUE_ARRAY_TYPE> vals = boost::get<std::vector<VALUE_ARRAY_TYPE>>(values);
1106 
1107  if (scale_epoch_values<BUILDER_TYPE>()) {
1108  auto scale_sec_to_millisec = [](auto seconds) { return seconds * kMilliSecsPerSec; };
1109  auto scale_values = [&](auto epoch) {
1110  return std::is_same<BUILDER_TYPE, arrow::Date32Builder>::value
1112  : scale_sec_to_millisec(epoch);
1113  };
1114  std::transform(vals.begin(), vals.end(), vals.begin(), scale_values);
1115  }
1116 
1117  auto typed_builder = dynamic_cast<BUILDER_TYPE*>(column_builder.builder.get());
1118  CHECK(typed_builder);
1119  if (column_builder.field->nullable()) {
1120  CHECK(is_valid.get());
1121  ARROW_THROW_NOT_OK(typed_builder->AppendValues(vals, *is_valid));
1122  } else {
1123  ARROW_THROW_NOT_OK(typed_builder->AppendValues(vals));
1124  }
1125 }
std::unique_ptr< arrow::ArrayBuilder > builder
#define ARROW_THROW_NOT_OK(s)
Definition: ArrowUtil.h:36
std::shared_ptr< arrow::Field > field
static constexpr int64_t kMilliSecsPerSec
#define CHECK(condition)
Definition: Logger.h:209
int64_t get_epoch_days_from_seconds(const int64_t seconds)

+ Here is the call graph for this function:

template<>
void anonymous_namespace{ArrowResultSetConverter.cpp}::appendToColumnBuilder< arrow::Decimal128Builder, int64_t > ( ArrowResultSetConverter::ColumnBuilder column_builder,
const ValueArray values,
const std::shared_ptr< std::vector< bool >> &  is_valid 
)

Definition at line 1128 of file ArrowResultSetConverter.cpp.

References ARROW_THROW_NOT_OK, CHECK, CHECK_EQ, and i.

1131  {
1132  std::vector<int64_t> vals = boost::get<std::vector<int64_t>>(values);
1133  auto typed_builder =
1134  dynamic_cast<arrow::Decimal128Builder*>(column_builder.builder.get());
1135  CHECK(typed_builder);
1136  CHECK_EQ(is_valid->size(), vals.size());
1137  if (column_builder.field->nullable()) {
1138  CHECK(is_valid.get());
1139  for (size_t i = 0; i < vals.size(); i++) {
1140  const auto v = vals[i];
1141  const auto valid = (*is_valid)[i];
1142  if (valid) {
1143  ARROW_THROW_NOT_OK(typed_builder->Append(v));
1144  } else {
1145  ARROW_THROW_NOT_OK(typed_builder->AppendNull());
1146  }
1147  }
1148  } else {
1149  for (const auto& v : vals) {
1150  ARROW_THROW_NOT_OK(typed_builder->Append(v));
1151  }
1152  }
1153 }
#define CHECK_EQ(x, y)
Definition: Logger.h:217
std::unique_ptr< arrow::ArrayBuilder > builder
#define ARROW_THROW_NOT_OK(s)
Definition: ArrowUtil.h:36
std::shared_ptr< arrow::Field > field
#define CHECK(condition)
Definition: Logger.h:209
template<>
void anonymous_namespace{ArrowResultSetConverter.cpp}::appendToColumnBuilder< arrow::StringDictionary32Builder, int32_t > ( ArrowResultSetConverter::ColumnBuilder column_builder,
const ValueArray values,
const std::shared_ptr< std::vector< bool >> &  is_valid 
)

Definition at line 1156 of file ArrowResultSetConverter.cpp.

References ARROW_THROW_NOT_OK, and CHECK.

1159  {
1160  auto typed_builder =
1161  dynamic_cast<arrow::StringDictionary32Builder*>(column_builder.builder.get());
1162  CHECK(typed_builder);
1163 
1164  std::vector<int32_t> vals = boost::get<std::vector<int32_t>>(values);
1165 
1166  if (column_builder.field->nullable()) {
1167  CHECK(is_valid.get());
1168  // TODO(adb): Generate this instead of the boolean bitmap
1169  std::vector<uint8_t> transformed_bitmap;
1170  transformed_bitmap.reserve(is_valid->size());
1171  std::for_each(
1172  is_valid->begin(), is_valid->end(), [&transformed_bitmap](const bool is_valid) {
1173  transformed_bitmap.push_back(is_valid ? 1 : 0);
1174  });
1175 
1176  ARROW_THROW_NOT_OK(typed_builder->AppendIndices(
1177  vals.data(), static_cast<int64_t>(vals.size()), transformed_bitmap.data()));
1178  } else {
1180  typed_builder->AppendIndices(vals.data(), static_cast<int64_t>(vals.size())));
1181  }
1182 }
std::unique_ptr< arrow::ArrayBuilder > builder
#define ARROW_THROW_NOT_OK(s)
Definition: ArrowUtil.h:36
std::shared_ptr< arrow::Field > field
#define CHECK(condition)
Definition: Logger.h:209
template<typename C_TYPE , typename ARROW_TYPE = typename arrow::CTypeTraits<C_TYPE>::ArrowType>
void anonymous_namespace{ArrowResultSetConverter.cpp}::convert_column ( ResultSetPtr  result,
size_t  col,
size_t  entry_count,
std::shared_ptr< arrow::Array > &  out 
)

Definition at line 180 of file ArrowResultSetConverter.cpp.

References CHECK, i, and run_benchmark_import::res.

183  {
184  CHECK(sizeof(C_TYPE) == result->getColType(col).get_size());
185 
186  std::shared_ptr<arrow::Buffer> values;
187  std::shared_ptr<arrow::Buffer> is_valid;
188  const int64_t buf_size = entry_count * sizeof(C_TYPE);
189  if (result->isZeroCopyColumnarConversionPossible(col)) {
190  values.reset(new ResultSetBuffer(
191  reinterpret_cast<const uint8_t*>(result->getColumnarBuffer(col)),
192  buf_size,
193  result));
194  } else {
195  auto res = arrow::AllocateBuffer(buf_size);
196  CHECK(res.ok());
197  values = std::move(res).ValueOrDie();
198  result->copyColumnIntoBuffer(
199  col, reinterpret_cast<int8_t*>(values->mutable_data()), buf_size);
200  }
201 
202  int64_t null_count = 0;
203  auto res = arrow::AllocateBuffer((entry_count + 7) / 8);
204  CHECK(res.ok());
205  is_valid = std::move(res).ValueOrDie();
206 
207  auto is_valid_data = is_valid->mutable_data();
208 
209  const null_type_t<C_TYPE>* vals =
210  reinterpret_cast<const null_type_t<C_TYPE>*>(values->data());
211  null_type_t<C_TYPE> null_val = null_type<C_TYPE>::value;
212 
213  size_t unroll_count = entry_count & 0xFFFFFFFFFFFFFFF8ULL;
214  for (size_t i = 0; i < unroll_count; i += 8) {
215  uint8_t valid_byte = 0;
216  uint8_t valid;
217  valid = vals[i + 0] != null_val;
218  valid_byte |= valid << 0;
219  null_count += !valid;
220  valid = vals[i + 1] != null_val;
221  valid_byte |= valid << 1;
222  null_count += !valid;
223  valid = vals[i + 2] != null_val;
224  valid_byte |= valid << 2;
225  null_count += !valid;
226  valid = vals[i + 3] != null_val;
227  valid_byte |= valid << 3;
228  null_count += !valid;
229  valid = vals[i + 4] != null_val;
230  valid_byte |= valid << 4;
231  null_count += !valid;
232  valid = vals[i + 5] != null_val;
233  valid_byte |= valid << 5;
234  null_count += !valid;
235  valid = vals[i + 6] != null_val;
236  valid_byte |= valid << 6;
237  null_count += !valid;
238  valid = vals[i + 7] != null_val;
239  valid_byte |= valid << 7;
240  null_count += !valid;
241  is_valid_data[i >> 3] = valid_byte;
242  }
243  if (unroll_count != entry_count) {
244  uint8_t valid_byte = 0;
245  for (size_t i = unroll_count; i < entry_count; ++i) {
246  bool valid = vals[i] != null_val;
247  valid_byte |= valid << (i & 7);
248  null_count += !valid;
249  }
250  is_valid_data[unroll_count >> 3] = valid_byte;
251  }
252 
253  if (!null_count) {
254  is_valid.reset();
255  }
256 
257  // TODO: support date/time + scaling
258  // TODO: support booleans
259  if (null_count) {
260  out.reset(
261  new arrow::NumericArray<ARROW_TYPE>(entry_count, values, is_valid, null_count));
262  } else {
263  out.reset(new arrow::NumericArray<ARROW_TYPE>(entry_count, values));
264  }
265 }
#define CHECK(condition)
Definition: Logger.h:209
template<typename TYPE >
void anonymous_namespace{ArrowResultSetConverter.cpp}::create_or_append_validity ( const ScalarTargetValue value,
const SQLTypeInfo col_type,
std::shared_ptr< std::vector< bool >> &  null_bitmap,
const size_t  max_size 
)

Definition at line 127 of file ArrowResultSetConverter.cpp.

References CHECK, SQLTypeInfo::get_notnull(), inline_fp_null_val(), inline_int_null_val(), SQLTypeInfo::is_boolean(), SQLTypeInfo::is_decimal(), SQLTypeInfo::is_dict_encoded_string(), SQLTypeInfo::is_fp(), SQLTypeInfo::is_integer(), SQLTypeInfo::is_time(), and UNREACHABLE.

130  {
131  if (col_type.get_notnull()) {
132  CHECK(!null_bitmap);
133  return;
134  }
135  auto pvalue = boost::get<TYPE>(&value);
136  CHECK(pvalue);
137  bool is_valid = false;
138  if (col_type.is_boolean()) {
139  is_valid = inline_int_null_val(col_type) != static_cast<int8_t>(*pvalue);
140  } else if (col_type.is_dict_encoded_string()) {
141  is_valid = inline_int_null_val(col_type) != static_cast<int32_t>(*pvalue);
142  } else if (col_type.is_integer() || col_type.is_time()) {
143  is_valid = inline_int_null_val(col_type) != static_cast<int64_t>(*pvalue);
144  } else if (col_type.is_fp()) {
145  is_valid = inline_fp_null_val(col_type) != static_cast<double>(*pvalue);
146  } else if (col_type.is_decimal()) {
147  is_valid = inline_int_null_val(col_type) != static_cast<int64_t>(*pvalue);
148  } else {
149  UNREACHABLE();
150  }
151 
152  if (!null_bitmap) {
153  null_bitmap = std::make_shared<std::vector<bool>>();
154  null_bitmap->reserve(max_size);
155  }
156  CHECK(null_bitmap);
157  null_bitmap->push_back(is_valid);
158 }
bool is_fp() const
Definition: sqltypes.h:513
#define UNREACHABLE()
Definition: Logger.h:253
double inline_fp_null_val(const SQL_TYPE_INFO &ti)
bool is_time() const
Definition: sqltypes.h:515
bool is_integer() const
Definition: sqltypes.h:511
bool is_boolean() const
Definition: sqltypes.h:516
#define CHECK(condition)
Definition: Logger.h:209
int64_t inline_int_null_val(const SQL_TYPE_INFO &ti)
bool is_dict_encoded_string() const
Definition: sqltypes.h:546
HOST DEVICE bool get_notnull() const
Definition: sqltypes.h:336
bool is_decimal() const
Definition: sqltypes.h:512

+ Here is the call graph for this function:

template<typename TYPE , typename VALUE_ARRAY_TYPE >
void anonymous_namespace{ArrowResultSetConverter.cpp}::create_or_append_value ( const ScalarTargetValue val_cty,
std::shared_ptr< ValueArray > &  values,
const size_t  max_size 
)

Definition at line 110 of file ArrowResultSetConverter.cpp.

References CHECK.

112  {
113  auto pval_cty = boost::get<VALUE_ARRAY_TYPE>(&val_cty);
114  CHECK(pval_cty);
115  auto val_ty = static_cast<TYPE>(*pval_cty);
116  if (!values) {
117  values = std::make_shared<ValueArray>(std::vector<TYPE>());
118  boost::get<std::vector<TYPE>>(*values).reserve(max_size);
119  }
120  CHECK(values);
121  auto values_ty = boost::get<std::vector<TYPE>>(values.get());
122  CHECK(values_ty);
123  values_ty->push_back(val_ty);
124 }
#define CHECK(condition)
Definition: Logger.h:209
std::shared_ptr<arrow::DataType> anonymous_namespace{ArrowResultSetConverter.cpp}::get_arrow_type ( const SQLTypeInfo sql_type,
const ExecutorDeviceType  device_type 
)

Definition at line 942 of file ArrowResultSetConverter.cpp.

References foreign_storage::get_physical_type(), SQLTypeInfo::get_precision(), SQLTypeInfo::get_scale(), SQLTypeInfo::get_type_name(), GPU, SQLTypeInfo::is_dict_encoded_string(), kARRAY, kBIGINT, kBOOLEAN, kCHAR, kDATE, kDECIMAL, kDOUBLE, kFLOAT, kINT, kINTERVAL_DAY_TIME, kINTERVAL_YEAR_MONTH, kNUMERIC, kSMALLINT, kTEXT, kTIME, kTIMESTAMP, kTINYINT, kVARCHAR, and to_string().

Referenced by ArrowResultSetConverter::makeField().

943  {
944  switch (get_physical_type(sql_type)) {
945  case kBOOLEAN:
946  return arrow::boolean();
947  case kTINYINT:
948  return arrow::int8();
949  case kSMALLINT:
950  return arrow::int16();
951  case kINT:
952  return arrow::int32();
953  case kBIGINT:
954  return arrow::int64();
955  case kFLOAT:
956  return arrow::float32();
957  case kDOUBLE:
958  return arrow::float64();
959  case kCHAR:
960  case kVARCHAR:
961  case kTEXT:
962  if (sql_type.is_dict_encoded_string()) {
963  auto value_type = std::make_shared<arrow::StringType>();
964  return dictionary(arrow::int32(), value_type, false);
965  }
966  return arrow::utf8();
967  case kDECIMAL:
968  case kNUMERIC:
969  return arrow::decimal(sql_type.get_precision(), sql_type.get_scale());
970  case kTIME:
971  return time32(arrow::TimeUnit::SECOND);
972  case kDATE: {
973  // TODO(wamsi) : Remove date64() once date32() support is added in cuDF. date32()
974  // Currently support for date32() is missing in cuDF.Hence, if client requests for
975  // date on GPU, return date64() for the time being, till support is added.
976  if (device_type == ExecutorDeviceType::GPU) {
977  return arrow::date64();
978  } else {
979  return arrow::date32();
980  }
981  }
982  case kTIMESTAMP:
983  switch (sql_type.get_precision()) {
984  case 0:
985  return timestamp(arrow::TimeUnit::SECOND);
986  case 3:
987  return timestamp(arrow::TimeUnit::MILLI);
988  case 6:
989  return timestamp(arrow::TimeUnit::MICRO);
990  case 9:
991  return timestamp(arrow::TimeUnit::NANO);
992  default:
993  throw std::runtime_error(
994  "Unsupported timestamp precision for Arrow result sets: " +
995  std::to_string(sql_type.get_precision()));
996  }
997  case kARRAY:
998  case kINTERVAL_DAY_TIME:
1000  default:
1001  throw std::runtime_error(sql_type.get_type_name() +
1002  " is not supported in Arrow result sets.");
1003  }
1004  return nullptr;
1005 }
Definition: sqltypes.h:49
HOST DEVICE int get_scale() const
Definition: sqltypes.h:334
parquet::Type::type get_physical_type(ReaderPtr &reader, const int logical_column_index)
std::string to_string(char const *&&v)
int get_precision() const
Definition: sqltypes.h:332
Definition: sqltypes.h:52
Definition: sqltypes.h:53
std::string get_type_name() const
Definition: sqltypes.h:432
Definition: sqltypes.h:41
bool is_dict_encoded_string() const
Definition: sqltypes.h:546
Definition: sqltypes.h:45

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

SQLTypes anonymous_namespace{ArrowResultSetConverter.cpp}::get_dict_index_type ( const SQLTypeInfo ti)
inline

Definition at line 73 of file ArrowResultSetConverter.cpp.

References CHECK, SQLTypeInfo::get_size(), SQLTypeInfo::get_type(), SQLTypeInfo::is_dict_encoded_string(), kBIGINT, kINT, kSMALLINT, and kTINYINT.

Referenced by ArrowResultSetConverter::initializeColumnBuilder().

73  {
75  switch (ti.get_size()) {
76  case 1:
77  return kTINYINT;
78  case 2:
79  return kSMALLINT;
80  case 4:
81  return kINT;
82  case 8:
83  return kBIGINT;
84  default:
85  CHECK(false);
86  }
87  return ti.get_type();
88 }
HOST DEVICE int get_size() const
Definition: sqltypes.h:339
HOST DEVICE SQLTypes get_type() const
Definition: sqltypes.h:329
#define CHECK(condition)
Definition: Logger.h:209
bool is_dict_encoded_string() const
Definition: sqltypes.h:546
Definition: sqltypes.h:45

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

SQLTypes anonymous_namespace{ArrowResultSetConverter.cpp}::get_physical_type ( const SQLTypeInfo ti)
inline

Definition at line 90 of file ArrowResultSetConverter.cpp.

References CHECK, SQLTypeInfo::get_size(), SQLTypeInfo::get_type(), IS_INTEGER, kBIGINT, kINT, kSMALLINT, and kTINYINT.

90  {
91  auto logical_type = ti.get_type();
92  if (IS_INTEGER(logical_type)) {
93  switch (ti.get_size()) {
94  case 1:
95  return kTINYINT;
96  case 2:
97  return kSMALLINT;
98  case 4:
99  return kINT;
100  case 8:
101  return kBIGINT;
102  default:
103  CHECK(false);
104  }
105  }
106  return logical_type;
107 }
HOST DEVICE int get_size() const
Definition: sqltypes.h:339
HOST DEVICE SQLTypes get_type() const
Definition: sqltypes.h:329
#define IS_INTEGER(T)
Definition: sqltypes.h:245
#define CHECK(condition)
Definition: Logger.h:209
Definition: sqltypes.h:45

+ Here is the call graph for this function:

std::pair<key_t, void*> anonymous_namespace{ArrowResultSetConverter.cpp}::get_shm ( size_t  shmsz)

Definition at line 268 of file ArrowResultSetConverter.cpp.

Referenced by arrow::get_and_copy_to_shm(), and get_shm_buffer().

268  {
269  if (!shmsz) {
270  return std::make_pair(IPC_PRIVATE, nullptr);
271  }
272  // Generate a new key for a shared memory segment. Keys to shared memory segments
273  // are OS global, so we need to try a new key if we encounter a collision. It seems
274  // incremental keygen would be deterministically worst-case. If we use a hash
275  // (like djb2) + nonce, we could still get collisions if multiple clients specify
276  // the same nonce, so using rand() in lieu of a better approach
277  // TODO(ptaylor): Is this common? Are these assumptions true?
278  auto key = static_cast<key_t>(rand());
279  int shmid = -1;
280  // IPC_CREAT - indicates we want to create a new segment for this key if it doesn't
281  // exist IPC_EXCL - ensures failure if a segment already exists for this key
282  while ((shmid = shmget(key, shmsz, IPC_CREAT | IPC_EXCL | 0666)) < 0) {
283  // If shmget fails and errno is one of these four values, try a new key.
284  // TODO(ptaylor): is checking for the last three values really necessary? Checking
285  // them by default to be safe. EEXIST - a shared memory segment is already associated
286  // with this key EACCES - a shared memory segment is already associated with this key,
287  // but we don't have permission to access it EINVAL - a shared memory segment is
288  // already associated with this key, but the size is less than shmsz ENOENT -
289  // IPC_CREAT was not set in shmflg and no shared memory segment associated with key
290  // was found
291  if (!(errno & (EEXIST | EACCES | EINVAL | ENOENT))) {
292  throw std::runtime_error("failed to create a shared memory");
293  }
294  key = static_cast<key_t>(rand());
295  }
296  // get a pointer to the shared memory segment
297  auto ipc_ptr = shmat(shmid, NULL, 0);
298  if (reinterpret_cast<int64_t>(ipc_ptr) == -1) {
299  throw std::runtime_error("failed to attach a shared memory");
300  }
301 
302  return std::make_pair(key, ipc_ptr);
303 }

+ Here is the caller graph for this function:

std::pair<key_t, std::shared_ptr<arrow::Buffer> > anonymous_namespace{ArrowResultSetConverter.cpp}::get_shm_buffer ( size_t  size)

Definition at line 306 of file ArrowResultSetConverter.cpp.

References get_shm().

Referenced by ArrowResultSetConverter::getArrowResult().

306  {
307 #ifdef _MSC_VER
308  throw std::runtime_error("Arrow IPC not yet supported on Windows.");
309  return std::make_pair(0, nullptr);
310 #else
311  auto [key, ipc_ptr] = get_shm(size);
312  std::shared_ptr<arrow::Buffer> buffer(
313  new arrow::MutableBuffer(static_cast<uint8_t*>(ipc_ptr), size));
314  return std::make_pair<key_t, std::shared_ptr<arrow::Buffer>>(std::move(key),
315  std::move(buffer));
316 #endif
317 }
std::pair< key_t, void * > get_shm(size_t shmsz)

+ Here is the call graph for this function:

+ Here is the caller graph for this function: