复杂类型数组的静态初始化

Question

I need static array of vectors initialized with custom Allocators in order to store my data (16 bytes each) in external ram. I use Howard Hinnant short alloc to do so, so far so good.

I use GCC and C++14:

Sequencer.h

    using FixedVector = std::vector<SequencerNoteEvent, short_alloc<SequencerNoteEvent, kBytesChunkMax, 4>>;

    /* memory pool */
    static char sequencerNoteEvent[2][600] __attribute__((section(".masection")));

    /* Declaration des différentes zones pour chaque vecteur */
    static arena<600> arena0 __attribute__((section(".masection")));
    static arena<600> arena1 __attribute__((section(".masection")));

     /* Declaration des Vectors utilisants les pools */
    static FixedVector v0 __attribute__((section(".masection")));
    static FixedVector v1 __attribute__((section(".masection")));

Sequencer.cpp

// ---------------
// STATIC VARIABLE
// ---------------
char Sequencer::sequencerNoteEvent[kMaxChunks][kBytesChunkMax];

arena<kBytesChunkMax> Sequencer::arena0{Sequencer::sequencerNoteEvent[0]};
FixedVector Sequencer::v0{Sequencer::arena0};
arena<kBytesChunkMax> Sequencer::arena1{Sequencer::sequencerNoteEvent[1]};
FixedVector Sequencer::v1{Sequencer::arena1};

I started with 2 memory pool, but i need 98304 of them... And i am totally stuck at initializing an array of these.

I tried this :

Sequencer.h

  /* Declaration de la memory pool */
  static char sequencerNoteEvent[2][600] __attribute__((section(".masection")));

  static arena<600> arenaa[2] __attribute__((section(".masection")));

  static FixedVector v[2] __attribute__((section(".masection")));

Sequencer.cpp

arena<600> Sequencer::arenaa[]{Sequencer::sequencerNoteEvent[0], Sequencer::sequencerNoteEvent[1]};
FixedVector Sequencer::v[]{Sequencer::arenaa[0], Sequencer::arenaa[1]};

 error: use of deleted function 'arena<N, alignment>::arena(const arena<N, alignment>&) [with unsigned int N = 600; unsigned int alignment = 4]'
 arena<kBytesChunkMax> Sequencer::arenaa[]{Sequencer::sequencerNoteEvent[0], Sequencer::sequencerNoteEvent[1]};

and if i allow the copy constructor (which is very likely to be a bad idea)

error: conversion from 'arena<600>' to non-scalar type 'pyrapro::FixedVector' {aka 'std::vector<pyrapro::SequencerNoteEvent, short_alloc<pyrapro::SequencerNoteEvent, 600, 4> >'} requested
 FixedVector Sequencer::v[]{Sequencer::arenaa[0], Sequencer::arenaa[1]};

Does someone have any clue of another way to initialize this ?

EDIT

Thanks a lot for your answer ! Actually i need to instantiate my vectors with custom allocators (short_alloc which redirect to arena in my case). So i need them to be constructed with an arena. Each arena stores and allocate an array in an external ram memory and short_alloc is the custom allocator itself which meets the requirements of the standard.

short_alloc(arena_type& a) noexcept : a_(a) {}

Unless i can change the allocator of a vector once it has already been constructed i don't see any other solution.

The move constructor in arena solved part of my issue, i still have :

error: conversion from 'arena<600>' to non-scalar type 'pyrapro::FixedVector' {aka 'std::vector<pyrapro::SequencerNoteEvent, short_alloc<pyrapro::SequencerNoteEvent, 600, 4> >'} requested

When i do this :

FixedVector Sequencer::v0{Sequencer::arena0};

i calls at initialization short_alloc(arena_type& a) which is fine. Why i am unable to do this multiple times ?

Of course if someone has an idea avoiding this huge initializer_list i am listening !

I tried to set the arena reference in short_alloc classes later with no success so far. References can't be null, i don't want to change all of this code i didn't write with pointers and init the FixedVectors with a reference to a dummy arena leads to the same initial issue.

Thanks,

Answer 1

The problem is that std::vector 's constructor from an allocator is explicit . When you do FixedVector fv{myArena}; all is good because you are explicitly constructing a FixedVector here. But with the array of FixedVector s, you are doing list initialization . Adding curly braces is not sufficient, you need to explicitly spell out the constructor.

Example to demonstrate:

using FV = std::vector<int>;
using FVA = FV::allocator_type;

FVA fva[3]{};

//FV fv[]{1, 2, 3}; // error: cannot convert from int to vector<int>
//FV fv[]{{1}, {2}, {3}}; // ok (nested list initialization)

//FV fv[]{fva[0], fva[1], fva[2]}; // error: cannot convert from FVA to FV
FV fv[]{FV{fva[0]}, FV{fva[1]}, FV{fva[2]}}; // ok

https://godbolt.org/z/X9a67T

Take note that this is not only tedious but also prone to initialization order fiasco. Not to mention that plain arrays are not good modern C++ style (but that's an orthogonal issue).

Answer 2

1. Define move constructor for arena . You should have something like this:

    // template or something class arena { public: arena(char arr[]) { /*...*/ } // I assume you have it like this. It remains. arena(const arena&) = delete; // Define your move constructor if you don't have one and // just move (assign) buffer pointers, etc. from moved instance to this. // Same for move assignment operator. arena(arena&&) = default; arena& operator=(arena&&) = default; // ... }; 

   Then the line

    arena<600> Sequencer::arenaa[]{Sequencer::sequencerNoteEvent[0], Sequencer::sequencerNoteEvent[1]}; 

   will work. Compiler will implicitly cast each element in the list to arena<600> and then move the contents to arenaa array elements.

2. You forgot nested curly brackets

   Edit: and, as Max Langhof pointed out, explicit FixedVector construction because of explicit std::vector constructor with single allocator argument.

    FixedVector Sequencer::v[]{Sequencer::arenaa[0], Sequencer::arenaa[1]}; 

   Fixed:

    FixedVector Sequencer::v[]{FixedVector{Sequencer::arenaa[0]}, FixedVector{Sequencer::arenaa[1]}}; 

Still it seems to me useless to fill your static arrays in initialisation, if you want to have over9000 elements instead of 2 in these arrays, as far as I understand from your question. I think you don't want to hardcode over9000 elements in those initializer lists. It will be more clever to initialise them with default values (empty for example), and then assign needed values in a loop. You can make a wrapper struct around your statics and create its static instance instead, then fill arrays in struct constructor. Something like this maybe:

class Sequencer {
    static struct Wrapper {
        using FixedVector = std::vector<SequencerNoteEvent>;
        char sequencerNoteEvent[2][600];
        arena<600> arenaa[2];
        FixedVector v[2];
        Wrapper() { 
            for (int i = 0; i < 2; i++) {
                arenaa[i] = arena<600>(sequencerNoteEvent[i]);
                v[i].emplace_back(arenaa[i]);
            }
        }
    } s_instance;
};