Wie vermeidet man C++ Code Bloat, der von Template Instanziierung und Symboltabelle ausgegeben wird?

Question

Ich hatte vor einigen Jahren ein Bare-Metal-Projekt (Cortex-M) gestartet. Bei der Projekteinrichtung haben wir uns entschieden, gcc toolchain mit C++ 11/C++ 14 usw. zu verwenden und sogar C++ - Ausnahmen und rtti zu verwenden.

Wir verwenden derzeit gcc 4.9 from launchpad.net/gcc-arm-embedded (mit einem Problem, das uns derzeit daran hindern, auf eine neuere GCC-Version zu aktualisieren).

Zum Beispiel würde ich schreibe eine Basisklasse und eine abgeleitete Klasse wie folgt (siehe auch laufendes Beispiel here):

class OutStream { 
public: 
    explicit OutStream() {} 
    virtual ~OutStream() {} 
    OutStream& operator << (const char* s) { 
     write(s, strlen(s)); 
     return *this; 
    } 
    virtual void write(const void* buffer, size_t size) = 0;  
}; 

class FixedMemoryStream: public OutStream { 
public: 
    explicit FixedMemoryStream(void* memBuffer, size_t memBufferSize): memBuffer(memBuffer), memBufferSize(memBufferSize) {} 
    virtual ~FixedMemoryStream()  {} 
    const void* getBuffer() const  { return memBuffer; } 
    size_t  getBufferSize() const { return memBufferSize; } 
    const char* getText() const  { return reinterpret_cast<const char*>(memBuffer); } ///< returns content as zero terminated C-string  
    size_t  getSize() const  { return index; }          ///< number of bytes really written to the buffer (max = buffersize-1) 
    bool   isOverflow() const { return overflow; } 
    virtual void write(const void* buffer, size_t size) override { /* ... */ } 
private: 
    void* memBuffer = nullptr; ///< buffer 
    size_t memBufferSize = 0;  ///< buffer size 
    size_t index = 0;    ///< current write index 
    bool overflow = false;  ///< flag if we are overflown 
}; 

Damit die Kunden meiner Klasse sind nun in der Lage zB zu verwenden:

char buffer[10]; 
FixedMemoryStream ms1(buffer, sizeof(buffer)); 
ms1 << "Hello World"; 

Jetzt möchte ich würde die Verwendung der Klasse etwas bequemer machen und stellte die folgende Vorlage:

template<size_t bufferSize> class FixedMemoryStreamWithBuffer: public FixedMemoryStream { 
public: 
    explicit FixedMemoryStreamWithBuffer(): FixedMemoryStream(buffer, bufferSize) {} 
private: 
    uint8_t buffer[bufferSize]; 
}; 

Und ab jetzt können meine Kunden schreiben:

FixedMemoryStreamWithBuffer<10> ms2; 
ms2 << "Hello World"; 

Aber von jetzt hatte ich zunehmende Größe meiner ausführbaren Binärdatei beobachtet. Es scheint, dass gcc Symbolinformationen für jede andere Template-Instanziierung von FixedMemoryStreamWithBuffer hinzugefügt hat (weil wir rtti aus irgendeinem Grund verwenden).

Könnte es eine Möglichkeit geben, Symbolinformationen nur für bestimmte Klassen/Vorlagen/Template-Instanziierungen zu entfernen?

Es ist in Ordnung, eine nicht portable gcc einzige Lösung dafür zu bekommen.

Aus irgendeinem Grund haben wir uns entschieden, Vorlagen anstelle von Präprozessor-Makros zu bevorzugen. Ich möchte eine Präprozessor-Lösung vermeiden.

Answer 1

Ja, es gibt eine Möglichkeit, die erforderlichen Symbole fast auf 0 zu bringen: Verwenden der Standardbibliothek. Ihre OutStream Klasse ist eine vereinfachte Version von std::basic_ostream. Ihr OutStream::write ist wirklich nur std::basic_ostream::write und so weiter. Werfen Sie einen Blick darauf here. Überlauf wird sehr genau gehandhabt, obwohl der Vollständigkeit halber auch underflow behandelt wird, d. H. Die Notwendigkeit des Datenabrufs; Sie können es als undefined lassen (es ist virtual auch).

In ähnlicher Weise ist Ihr FixedMemoryStreamstd::basic_streambuf<T> mit einer festen Größe (a std::array<T>) Get/Put-Bereich.

Also, machen Sie einfach Ihre Klassen von den Standard-Erben und Sie werden auf Binärgröße abgeschnitten, da Sie bereits deklarierte Symbole wiederverwenden.

---

Jetzt in Bezug auf template<size_t bufferSize> class FixedMemoryStreamWithBuffer. Diese Klasse ist sehr ähnlich wie std::array<std::uint8_t, bufferSize> für die Art und Weise wie Speicher angegeben und erworben wird. Sie kann nicht viel darüber optimieren: jede Instanziierung ist eine verschiedene Art mit allem, was das bedeutet. Der Compiler kann nicht "verschmelzen" oder irgendetwas Magisches an ihnen vornehmen: Jede Instanz muss ihren eigenen Typ haben. Also entweder auf std::vector oder haben einige feste Größe spezialisierte Stücke, wie 32, 128 usw. und für irgendwelche Werte dazwischen würde die richtige wählen; Dies kann vollständig zur Kompilierungszeit erreicht werden, also keine Laufzeitkosten.

Answer 2

Denken Sie daran, dass der Compiler für jede Instanz des FixedMemoryStreamWithBuffer <> sowie für jede Klasse in der Vererbungskette auch separate v-table- (sowie RTTI-Informationen) generiert.

Um das Problem zu lösen ich mit einiger Konvertierungsfunktion und/oder Betreiber innen mit Haltung statt Vererbung empfehlen würde:

template<size_t bufferSize> 
    class FixedMemoryStreamWithBuffer 
    { 
     uint8_t buffer[bufferSize]; 
     FixedMemoryStream m_stream; 
    public: 
     explicit FixedMemoryStreamWithBuffer() : m_stream(m_buffer, bufferSize) {} 
     operator FixedMemoryStream&() { return m_stream; } 
     FixedMemoryStream& toStream() { return m_stream; } 
    };