Wie kann festgestellt werden, ob der Speicher ausgerichtet ist?

Question 1

Ich bin neu in der Optimierung von Code mit SSE/SSE2-Anweisungen und bis jetzt bin ich nicht sehr weit gekommen. Meines Wissens würde eine übliche SSE-optimierte Funktion so aussehen:

void sse_func(const float* const ptr, int len){
    if( ptr is aligned )
    {
        for( ... ){
            // unroll loop by 4 or 2 elements
        }
        for( ....){
            // handle the rest
            // (non-optimized code)
        }
    } else {
        for( ....){
            // regular C code to handle non-aligned memory
        }
    }
}

Wie kann ich jedoch richtig feststellen, ob der Speicher ptr zeigt auf ist ausgerichtet auf zB 16 Bytes? Ich denke, ich muss den regulären C-Codepfad für nicht ausgerichteten Speicher einschließen, da ich nicht sicherstellen kann, dass jeder Speicher, der an diese Funktion übergeben wird, ausgerichtet wird. Und die Verwendung der Intrinsics zum Laden von Daten aus dem nicht ausgerichteten Speicher in die SSE-Register scheint schrecklich langsam zu sein (sogar langsamer als normaler C-Code).

Danke im Voraus…

Question 2

#define is_aligned(POINTER, BYTE_COUNT) \
    (((uintptr_t)(const void *)(POINTER)) % (BYTE_COUNT) == 0)

Die Besetzung zu void * (oder Äquivalent, char *) ist notwendig, da der Standard nur eine invertierbare Konvertierung zu garantiert uintptr_t zum void *.

Wenn Sie Typsicherheit wünschen, sollten Sie eine Inline-Funktion verwenden:

static inline _Bool is_aligned(const void *restrict pointer, size_t byte_count)
{ return (uintptr_t)pointer % byte_count == 0; }

und auf Compiler-Optimierungen hoffen, wenn byte_count ist eine Kompilierzeitkonstante.

Warum müssen wir umwandeln? void * ?

Die C-Sprache erlaubt verschiedene Darstellungen für verschiedene Zeigertypen, zB könnten Sie einen 64-Bit haben void * Typ (der gesamte Adressraum) und ein 32-Bit foo * Typ (ein Segment).

Die Umwandlung foo * -> void * kann eine tatsächliche Berechnung beinhalten, z. B. das Hinzufügen eines Offsets. Der Standard überlässt es auch der Implementierung, was passiert, wenn (beliebige) Zeiger in Ganzzahlen umgewandelt werden, aber ich vermute, dass es oft als Noop implementiert wird.

Für eine solche Implementierung foo * -> uintptr_t -> foo * würde funktionieren, aber foo * -> uintptr_t -> void * und void * -> uintptr_t -> foo * würde nicht. Die Alignment-Berechnung würde auch nicht zuverlässig funktionieren, weil Sie nur die Alignment relativ zum Segment-Offset prüfen, was Ihren Wünschen entsprechen kann oder auch nicht.

Fazit: Immer verwenden void * um implementierungsunabhängiges Verhalten zu erhalten.

Question 3

EDIT: Gießen zu long ist eine billige Möglichkeit, sich gegen die wahrscheinlichste Möglichkeit zu schützen, dass int und Zeiger heutzutage unterschiedliche Größen haben.

Wie in den Kommentaren unten erwähnt, gibt es bessere Lösungen, wenn Sie bereit sind, einen Header einzufügen …

Ein Zeiger p ist an einer 16-Byte-Grenze iff ausgerichtet ((unsigned long)p & 15) == 0.

Question 4

Andere Antworten schlagen eine UND-Operation vor, bei der niedrige Bits gesetzt sind und mit Null verglichen werden.

Ein einfacherer Test wäre jedoch, eine MOD mit dem gewünschten Ausrichtungswert durchzuführen und mit Null zu vergleichen.

#define ALIGNMENT_VALUE     16u

if (((uintptr_t)ptr % ALIGNMENT_VALUE) == 0)
{
    // ptr is aligned
}

Question 5

Mit einer Funktionsvorlage wie

#include <type_traits>

template< typename T >
bool is_aligned(T* p){
    return !(reinterpret_cast<uintptr_t>(p) % std::alignment_of<T>::value);
}

Sie könnten die Ausrichtung zur Laufzeit überprüfen, indem Sie so etwas wie aufrufen

struct foo_type{ int bar; }foo;
assert(is_aligned(&foo)); // passes

Um zu überprüfen, ob schlechte Ausrichtungen fehlschlagen, könnten Sie dies tun

// would almost certainly fail
assert(is_aligned((foo_type*)(1 + (uintptr_t)(&foo)));

Question 6

Dies ist im Grunde das, was ich benutze. Indem ich die Ganzzahl zu einer Vorlage mache, stelle ich sicher, dass die Kompilierzeit verlängert wird, sodass ich bei allem, was ich tue, nicht mit einer langsamen Modulo-Operation enden werde.

Ich überprüfe immer gerne meine Eingaben, daher die Behauptung zur Kompilierzeit. Wenn Ihr Ausrichtungswert falsch ist, wird es nicht kompiliert …

template <unsigned int alignment>
struct IsAligned
{
    static_assert((alignment & (alignment - 1)) == 0, "Alignment must be a power of 2");

    static inline bool Value(const void * ptr)
    {
        return (((uintptr_t)ptr) & (alignment - 1)) == 0;
    }
};

Um zu sehen, was los ist, können Sie Folgendes verwenden:

// 1 of them is aligned...
int* ptr = new int[8];
for (int i = 0; i < 8; ++i)
    std::cout << IsAligned<32>::Value(ptr + i) << std::endl;

// Should give '1'
int* ptr2 = (int*)_aligned_malloc(32, 32);
std::cout << IsAligned<32>::Value(ptr2) << std::endl;

Question 7

Überlassen Sie das den Profis,

https://www.boost.org/doc/libs/1_65_1/doc/html/align/reference.html#align.reference.functions.is_aligned

bool is_aligned(const void* ptr, std::size_t alignment) noexcept;

Beispiel:

        char D[1];
        assert( boost::alignment::is_aligned(&D[0], alignof(double)) ); //  might fail, sometimes

Question 8

Können Sie den ptr einfach mit 0x03 (ausgerichtet auf 4s), 0x07 (ausgerichtet auf 8s) oder 0x0f (ausgerichtet auf 16s) ‘und’, um zu sehen, ob eines der niedrigsten Bits gesetzt ist?