我有一个来自模板参数的 4 个类型字段的结构:

template <typename T1, typename T2, typename T3, typename T4>
struct __attribute__((aligned(8))) four_tuple {
  typedef struct {
    T1 t1;
    T2 t2;
    T3 t3;
    T4 t4;
  } payload;
  payload p;
};

每种类型 T1 , T2 , T3 , 和 T4 , 保证是原始类型或 four_tuple<...>::payload类型。保证是递归的——您可以将结构视为对 quadtree 进行编码其叶节点是原始类型。

我的目标是使结构尽可能少 sizeof ，条件是所有叶节点都正确对齐。允许优化的工具是类模板特化，使用:

• 字段重新排序 t1 , t2 , t3 , t4
• 添加填充字段
• gcc 属性 packed在 payload
• 也许其他人？

我觉得使用 enable_if 可以巧妙地解决这个问题和 SFINAE。谁能找到它？

为了说明问题，如果我们按原样使用上面的实现 using Foo = four_tuple<char,double,char,double> ，我们将有效负载和整体的大小设置为 32。如果我们简单地声明负载 packed , double的不会对齐。以降序重新排序字段的模板特化(此处为 double, double, char, char )将提供 24 的有效负载和总大小。但是它使用的额外 6 个字节是浪费的，考虑到 using Bar = four_tuple<Foo::payload,int,int,int> 可以看出这一点。 .带优化包装Bar可以容纳 32 个字节，但使用此方案需要 40 个字节。直截了本地应用字段重新排序 packed将导致未对齐 int在 Bar 中- 需要一些填充物。

我知道，一般来说，由于缓存方面的考虑，重构结构字段的内存布局可能会对性能产生影响，而且一般来说，这些影响至少与更好的打包带来的任何潜在 yield 一样重要。不过，我想探索权衡，如果不解决这个问题，我就无法在我的上下文中正确地做到这一点。

最佳答案

嵌套元组情况下的大问题是您想要一个类型为 four_tuple<char,double,char,double>::payload 的字段, 对齐就好像它是 four_tuple<char,double,char,double> ，但不需要容器类型继承其对齐方式。这是复杂的。这样做是可能的，但它会使您的代码无法移植到 GCC 以外的任何地方。我想这没关系，因为您已经在您的问题中建议了 GCC 扩展。基本思想是位字段可用于插入填充以确保对齐:

struct __attribute__((packed)) S {
  char c; // at offset 0
  int i; // at offset 1, not aligned
  int : 0;
  int j; // at offset 8, aligned
  int : 0;
  int k; // at offset 12, no extra padding between j and k
};

int当然是一种非常特殊的类型，具有非常特殊的对齐方式，您需要动态确定的对齐方式。幸运的是，GCC 允许 char 类型的位域，通常只强制字节对齐，与 alignas 结合使用, 确保任意对齐。

完成后，您可以检查所有 24 种可能的字段排序并选择总大小最小的负载。我将有效负载设为全局类型，并为其提供了一个额外的模板参数来指示字段顺序。这允许 tuple4<T1, T2, T3, T4>检查tuple4_payload<T1, T2, T3, T4, 1234> , tuple4_payload<T1, T2, T3, T4, 1243>等，然后选择最好的。

template <typename...> struct smallest;
template <typename...T> using smallest_t = typename smallest<T...>::type;

template <typename T> struct smallest<T> { using type = T; };
template <typename T, typename...Ts> struct smallest<T, Ts...> { using type = std::conditional_t<sizeof(T) <= sizeof(smallest_t<Ts...>), T, smallest_t<Ts...>>; };

template <typename T1, typename T2, typename T3, typename T4> struct tuple4;
template <typename T1, typename T2, typename T3, typename T4, int fieldOrder> struct tuple4_payload;
template <typename T1, typename T2, typename T3, typename T4> struct tuple4_simple { T1 t1; T2 t2; T3 t3; T4 t4; };

template <typename T> struct extract_payload { using type = T; };
template <typename...T> struct extract_payload<tuple4<T...>> { using type = typename tuple4<T...>::payload; };
template <typename T> using extract_payload_t = typename extract_payload<T>::type;

#define PERMS \
  PERM(1,2,3,4) PERM(1,2,4,3) PERM(1,3,2,4) PERM(1,3,4,2) PERM(1,4,2,3) PERM(1,4,3,2) \
  PERM(2,1,3,4) PERM(2,1,4,3) PERM(2,3,1,4) PERM(2,3,4,1) PERM(2,4,1,3) PERM(2,4,3,1) \
  PERM(3,1,2,4) PERM(3,1,4,2) PERM(3,2,1,4) PERM(3,2,4,1) PERM(3,4,1,2) PERM(3,4,2,1) \
  PERM(4,1,2,3) PERM(4,1,3,2) PERM(4,2,1,3) PERM(4,2,3,1) PERM(4,3,1,2) PERM(4,3,2,1)

#define PERM(a,b,c,d) \
  template <typename T1, typename T2, typename T3, typename T4> \
  struct __attribute__((packed)) tuple4_payload<T1, T2, T3, T4, a##b##c##d> { \
    char : 0 alignas(T##a); extract_payload_t<T##a> t##a; \
    char : 0 alignas(T##b); extract_payload_t<T##b> t##b; \
    char : 0 alignas(T##c); extract_payload_t<T##c> t##c; \
    char : 0 alignas(T##d); extract_payload_t<T##d> t##d; \
  };
PERMS
#undef PERM

#define PERM(a,b,c,d) , tuple4_payload<T1, T2, T3, T4, a##b##c##d>
template <typename, typename...T> using tuple4_smallest_payload_t = smallest_t<T...>;
template <typename T1, typename T2, typename T3, typename T4>
struct alignas(tuple4_simple<T1, T2, T3, T4>) tuple4 : tuple4_smallest_payload_t<void PERMS> {
  using payload = tuple4_smallest_payload_t<void PERMS>;
};
#undef PERM

在您的情况下，您可以将其用作 tuple4<int, tuple4<char, double, char, double>, int, int> .请注意，即使此处未明确提及有效载荷类型，它仍将用于 t2。成员(member)。

关于c++ - 在不丢失对齐的情况下优化打包递归模板化结构，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/34671612/