Discussion :

[Flodelarab]

Bonjour

Avez-vous des astuces pour allouer 4294967296 booléens, en C++ ? Sur une machine sous Linux, sans préparation spéciale, il veut bien 429496729 booléens (400 millions au lieu de 4 milliards), mais si je rajoute un chiffre 6, 5, 4 ou 0, il plante. 4194967290 le fait déjà planter.

Je ne suis pas fan d'allouer un octet entier pour n'utiliser qu'un seul bit, mais si je multiplexe les données, je devrai me coltiner le démultiplexage.

Quelle solution cela vous inspire-t-il ?

Merci de votre attention.

[Jamatronic]

Si tu as besoin d'autant de booléens, il est insensé de réserver un octet entier pour chacun.

Tu sais comment diviser par huit la taille de données dont tu as besoin, et le faire fait partie des compétences DE BASE d'un développeur.

Pas d'excuse...


D'un autre côté, on serait curieux de savoir pourquoi tu aurais besoin de stocker tout cela en RAM, à un instant donné et en un seul bloc...

Est-ce que le problème ne se situerait pas en amont ?

[jo_link_noir]

Il y a aussi std::bitset qui fait le taff.

[AbsoluteLogic]

Il y a aussi std::bitset qui fait le taff.

Malheureusement, bitset n'accepte que des tailles fixes à la compilation, et de fait, j'imagine que la mémoire est allouée dans la pile, dont la taille est très limitée (j'ai testé avec les 4 Gbits, et ça segfault). Pour de si grandes tailles, on a besoin d'allocations dynamiques. La page https://en.cppreference.com/w/cpp/utility/bitset donne justement un lien vers une implémentation dynamique fournie par Boost.

Mais si on veut éviter l'usage de Boost, comme l'a dit Jamatronic, l'implémentation se fait rapidement soit-même, en utilisant l'orienté objet pour éviter d'avoir à faire soit-même le "démultiplexage". Voici donc une implémentation que j'ai fait vite fait pour tester si les 4 GigaBits sont bien supportés (et ils le sont) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
#include <iostream>
#include <vector>
#include <cstdint>
 
class bitset {
public:
    bitset(size_t n) :
        _data((n + 7) / 8)
    { }
    class bit_handle {
    public:
        bit_handle(uint8_t& byte, uint8_t mask) :
            _byte(byte),
            _mask(mask)
        { }
        bit_handle& operator=(bool bit) {
            if (bit)
                _byte |= _mask;
            else
                _byte &= ~_mask;
            return *this;
        }
        operator bool() const {
            return _byte & _mask;
        }
    private:
        uint8_t& _byte;
        uint8_t _mask;
    };
    bit_handle operator[](size_t i) {
        return bit_handle(
            _data[i / 8],
            1u << (i % 8)
        );
    }
private:
    std::vector<uint8_t> _data;
};
 
#define SIZE 4294967296
 
int main(int, char**) {
    bitset bits(SIZE);
    bits[SIZE / 2] = true;
    std::cout << bits[SIZE / 2] << std::endl;
    bits[SIZE / 2] = false;
    std::cout << bits[SIZE / 2] << std::endl;
    /*for (int i=0; i < SIZE; ++i)
        std::cout << (bits[i] ? 1 : 0);
    std::cout << std::endl;*/
    return 0;
}

[droggo]

Bonjour,

Comme Jamatronic, je me demande à quoi peuvent servir autant de booléens.

[WhiteCrow]

Hello,
4Go ? Linux ? Le premier truc qui me vient à l'esprit est : mmap.
Mais bon … avec des bit-tricks tu passes à 500Mo.