absl::FixedArray — 런타임 크기 stack 배열

1
void Process(absl::string_view input) {
2
  std::vector<char> buf(input.size());  // 항상 heap alloc
3
  // 버퍼 사용
4
}

1
void Process(absl::string_view input) {
2
  absl::FixedArray<char, 256> buf(input.size());
3
  // input.size() ≤ 256이면 stack, 아니면 heap
4
}

1
#include "absl/container/fixed_array.h"
2

3
namespace absl {
4
template <typename T, size_t N = inline_default, typename A = std::allocator<T>>
5
class FixedArray {
6
 public:
7
  explicit FixedArray(size_t n);
8
  FixedArray(size_t n, const T& fill);
9
  FixedArray(std::initializer_list<T> init);
10
  template <typename Iter> FixedArray(Iter first, Iter last);
11

12
  T& operator[](size_t i);
13
  T& at(size_t i);
14
  T* data();
15
  size_t size() const;
16
  bool empty() const;
17
  T* begin(); T* end();
18
  // ...
19
};
20
}

1
absl::FixedArray<int, 16> a(n);              // 0으로 초기화되지 않음 (trivial T)
2
absl::FixedArray<int, 16> b(n, 0);           // 0으로 채움
3
absl::FixedArray<int, 16> c{1, 2, 3, 4};     // 4 원소
4

5
for (int& x : a) x = compute();

1
// 64개까지 stack
2
absl::FixedArray<int, 64> a(n);
3

4
// 0개 — 항상 heap
5
absl::FixedArray<int, 0> b(n);

1
// absl/container/fixed_array.h (요약)
2
template <typename T, size_t N, typename A>
3
class FixedArray {
4
  size_t size_;
5
  T* data_;
6

7
  union {
8
    char inline_storage_[N * sizeof(T)];
9
    // heap-alloc 시 사용하지 않음
10
  };
11

12
 public:
13
  explicit FixedArray(size_t n) : size_(n) {
14
    if (n <= N) {
15
      data_ = reinterpret_cast<T*>(inline_storage_);
16
    } else {
17
      data_ = AllocateHeap(n);
18
    }
19
    ConstructDefault(data_, n);
20
  }
21

22
  ~FixedArray() {
23
    DestroyAll();
24
    if (size_ > N) DeallocateHeap();
25
  }
26
};

1
// 회피 — 매 호출 heap alloc
2
void Encode(absl::string_view in, std::string* out) {
3
  std::vector<char> tmp(in.size() * 2);
4
  // ...
5
}
6

7
// Good
8
void Encode(absl::string_view in, std::string* out) {
9
  absl::FixedArray<char, 1024> tmp(in.size() * 2);
10
  // 대부분 입력에서 stack 사용
11
}

1
// N개 worker로 분배
2
void Dispatch(const Task& t, size_t worker_count) {
3
  absl::FixedArray<TaskPart, 16> parts(worker_count);
4
  for (size_t i = 0; i < worker_count; ++i) {
5
    parts[i] = MakePart(t, i, worker_count);
6
  }
7
  // 보통 worker_count ≤ 16, stack 경로
8
}

1
ssize_t needed = some_c_function(nullptr, 0);
2
absl::FixedArray<char, 256> buf(needed);
3
some_c_function(buf.data(), needed);

1
absl::FixedArray<int, 100000> a(n);   // sizeof(FixedArray) ≥ 400 KB

1
absl::FixedArray<int, 256> a(n);
2
// n이 256 이하면 stack
3
// 그런데 sizeof(int)*256 = 1KB가 매 호출 stack 사용
4
// 재귀 함수면 깊이 1000에서 1MB