make arrays follow alignment as well.

Author: vchuravy

src/array.c

@@ -48,7 +48,7 @@ size_t jl_arr_xtralloc_limit = 0;
 #define MAXINTVAL (((size_t)-1)>>1)
 
 static jl_array_t *_new_array_(jl_value_t *atype, uint32_t ndims, size_t *dims,
-                               int isunboxed, int elsz)
+                               int isunboxed, int elsz, int elalign)
 {
     jl_ptls_t ptls = jl_get_ptls_states();
     size_t i, tot, nel=1;
@@ -87,11 +87,11 @@ static jl_array_t *_new_array_(jl_value_t *atype, uint32_t ndims, size_t *dims,
     int tsz = JL_ARRAY_ALIGN(sizeof(jl_array_t) + ndimwords*sizeof(size_t), JL_CACHE_BYTE_ALIGNMENT);
     if (tot <= ARRAY_INLINE_NBYTES) {
         if (isunboxed && elsz >= 4)
-            tsz = JL_ARRAY_ALIGN(tsz, JL_SMALL_BYTE_ALIGNMENT); // align data area
+            tsz = JL_ARRAY_ALIGN(tsz, elalign); // align data area
         size_t doffs = tsz;
         tsz += tot;
         tsz = JL_ARRAY_ALIGN(tsz, JL_SMALL_BYTE_ALIGNMENT); // align whole object
-        a = (jl_array_t*)jl_gc_alloc(ptls, tsz, JL_SMALL_BYTE_ALIGNMENT, atype);
+        a = (jl_array_t*)jl_gc_alloc(ptls, tsz, elalign, atype);
         // No allocation or safepoint allowed after this
         a->flags.how = 0;
         data = (char*)a + doffs;
@@ -122,6 +122,7 @@ static jl_array_t *_new_array_(jl_value_t *atype, uint32_t ndims, size_t *dims,
     a->flags.ndims = ndims;
     a->flags.ptrarray = !isunboxed;
     a->elsize = elsz;
+    a->elalign = elalign;
     a->flags.isshared = 0;
     a->flags.isaligned = 1;
     a->offset = 0;
@@ -147,14 +148,13 @@ static inline jl_array_t *_new_array(jl_value_t *atype, uint32_t ndims, size_t *
         elsz = sizeof(void*);
         al = elsz;
     }
-
-    return _new_array_(atype, ndims, dims, isunboxed, elsz);
+    return _new_array_(atype, ndims, dims, isunboxed, elsz, al);
 }
 
 jl_array_t *jl_new_array_for_deserialization(jl_value_t *atype, uint32_t ndims, size_t *dims,
-                                             int isunboxed, int elsz)
+                                             int isunboxed, int elsz, int elalign)
 {
-    return _new_array_(atype, ndims, dims, isunboxed, elsz);
+    return _new_array_(atype, ndims, dims, isunboxed, elsz, elalign);
 }
 
 #ifndef JL_NDEBUG
@@ -197,6 +197,7 @@ JL_DLLEXPORT jl_array_t *jl_reshape_array(jl_value_t *atype, jl_array_t *data,
     assert(isboxed == data->flags.ptrarray);
     if (!isboxed) {
         a->elsize = elsz;
+        a->elalign = align;
         jl_value_t *ownerty = jl_typeof(owner);
         size_t oldelsz = 0, oldalign = 0;
         if (ownerty == (jl_value_t*)jl_string_type) {
@@ -213,6 +214,7 @@ JL_DLLEXPORT jl_array_t *jl_reshape_array(jl_value_t *atype, jl_array_t *data,
     }
     else {
         a->elsize = sizeof(void*);
+        a->elalign = sizeof(void*);
         a->flags.ptrarray = 1;
     }
 
@@ -266,6 +268,7 @@ JL_DLLEXPORT jl_array_t *jl_string_to_array(jl_value_t *str)
     a->data = jl_string_data(str);
     a->flags.isaligned = 0;
     a->elsize = 1;
+    a->elalign = 0;
     a->flags.ptrarray = 0;
     jl_array_data_owner(a) = str;
     a->flags.how = 3;
@@ -305,14 +308,15 @@ JL_DLLEXPORT jl_array_t *jl_ptr_to_array_1d(jl_value_t *atype, void *data,
 
     int ndimwords = jl_array_ndimwords(1);
     int tsz = JL_ARRAY_ALIGN(sizeof(jl_array_t) + ndimwords*sizeof(size_t), JL_CACHE_BYTE_ALIGNMENT);
-    a = (jl_array_t*)jl_gc_alloc(ptls, tsz, JL_CACHE_BYTE_ALIGNMENT, atype);
+    a = (jl_array_t*)jl_gc_alloc(ptls, tsz, align, atype);
     // No allocation or safepoint allowed after this
     a->flags.pooled = tsz <= GC_MAX_SZCLASS;
     a->data = data;
 #ifdef STORE_ARRAY_LEN
     a->length = nel;
 #endif
     a->elsize = elsz;
+    a->elalign = align;
     a->flags.ptrarray = !isunboxed;
     a->flags.ndims = 1;
     a->flags.isshared = 1;
@@ -371,14 +375,15 @@ JL_DLLEXPORT jl_array_t *jl_ptr_to_array(jl_value_t *atype, void *data,
 
     int ndimwords = jl_array_ndimwords(ndims);
     int tsz = JL_ARRAY_ALIGN(sizeof(jl_array_t) + ndimwords*sizeof(size_t), JL_CACHE_BYTE_ALIGNMENT);
-    a = (jl_array_t*)jl_gc_alloc(ptls, tsz, JL_CACHE_BYTE_ALIGNMENT, atype);
+    a = (jl_array_t*)jl_gc_alloc(ptls, tsz, align, atype);
     // No allocation or safepoint allowed after this
     a->flags.pooled = tsz <= GC_MAX_SZCLASS;
     a->data = data;
 #ifdef STORE_ARRAY_LEN
     a->length = nel;
 #endif
     a->elsize = elsz;
+    a->elalign = align;
     a->flags.ptrarray = !isunboxed;
     a->flags.ndims = ndims;
     a->offset = 0;
@@ -1042,9 +1047,10 @@ JL_DLLEXPORT void jl_array_sizehint(jl_array_t *a, size_t sz)
 JL_DLLEXPORT jl_array_t *jl_array_copy(jl_array_t *ary)
 {
     size_t elsz = ary->elsize;
+    size_t elalign = ary->elalign;
     size_t len = jl_array_len(ary);
     jl_array_t *new_ary = _new_array_(jl_typeof(ary), jl_array_ndims(ary),
-                                      &ary->nrows, !ary->flags.ptrarray, elsz);
+                                      &ary->nrows, !ary->flags.ptrarray, elsz, elalign);
     memcpy(new_ary->data, ary->data, len * elsz);
     // ensure isbits union arrays copy their selector bytes correctly
     if (!ary->flags.ptrarray && jl_is_uniontype(jl_tparam0(jl_typeof(ary)))) {

src/dump.c

@@ -577,11 +577,13 @@ static void jl_serialize_value_(jl_serializer_state *s, jl_value_t *v, int as_li
         if (ar->flags.ndims == 1 && ar->elsize < 128) {
             writetag(s->s, (jl_value_t*)Array1d_tag);
             write_uint8(s->s, (ar->flags.ptrarray<<7) | (ar->elsize & 0x7f));
+            write_uint8(s->s, ar->elalign & 0x7f);
         }
         else {
             writetag(s->s, (jl_value_t*)jl_array_type);
             write_uint16(s->s, ar->flags.ndims);
             write_uint16(s->s, (ar->flags.ptrarray<<15) | (ar->elsize & 0x7fff));
+            write_uint16(s->s, ar->elalign);
         }
         for (i=0; i < ar->flags.ndims; i++)
             jl_serialize_value(s, jl_box_long(jl_array_dim(ar,i)));
@@ -1329,18 +1331,22 @@ static jl_value_t *jl_deserialize_value_array(jl_serializer_state *s, jl_value_t
 {
     int usetable = (s->mode != MODE_AST);
     int16_t i, ndims;
-    int isunboxed, elsize;
+    int isunboxed, elsize, elalign;
     if (vtag == (jl_value_t*)Array1d_tag) {
         ndims = 1;
         elsize = read_uint8(s->s);
+        elalign = read_uint8(s->s);
         isunboxed = !(elsize >> 7);
         elsize = elsize & 0x7f;
+        elalign = elalign & 0x7f;
     }
     else {
         ndims = read_uint16(s->s);
         elsize = read_uint16(s->s);
+        elalign = read_uint16(s->s);
         isunboxed = !(elsize >> 15);
         elsize = elsize & 0x7fff;
+        elalign = elalign & 0x7fff;
     }
     uintptr_t pos = backref_list.len;
     if (usetable)
@@ -1349,7 +1355,7 @@ static jl_value_t *jl_deserialize_value_array(jl_serializer_state *s, jl_value_t
     for (i = 0; i < ndims; i++) {
         dims[i] = jl_unbox_long(jl_deserialize_value(s, NULL));
     }
-    jl_array_t *a = jl_new_array_for_deserialization((jl_value_t*)NULL, ndims, dims, isunboxed, elsize);
+    jl_array_t *a = jl_new_array_for_deserialization((jl_value_t*)NULL, ndims, dims, isunboxed, elsize, elalign);
     if (usetable)
         backref_list.items[pos] = a;
     jl_value_t *aty = jl_deserialize_value(s, &jl_astaggedvalue(a)->type);

src/julia.h

@@ -155,6 +155,7 @@ JL_EXTENSION typedef struct {
 #endif
     jl_array_flags_t flags;
     uint16_t elsize;
+    uint16_t elalign;
     uint32_t offset;  // for 1-d only. does not need to get big.
     size_t nrows;
     union {

src/julia_internal.h

@@ -488,7 +488,7 @@ JL_DLLEXPORT jl_value_t *jl_argument_datatype(jl_value_t *argt);
 jl_value_t *jl_nth_slot_type(jl_value_t *sig, size_t i);
 void jl_compute_field_offsets(jl_datatype_t *st);
 jl_array_t *jl_new_array_for_deserialization(jl_value_t *atype, uint32_t ndims, size_t *dims,
-                                             int isunboxed, int elsz);
+                                             int isunboxed, int elsz, int elalign);
 void jl_module_run_initializer(jl_module_t *m);
 extern jl_array_t *jl_module_init_order;
 extern union jl_typemap_t jl_cfunction_list;