make arrays follow alignment as well.

Author: vchuravy

src/array.c

@@ -54,7 +54,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;
@@ -89,11 +89,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;
@@ -123,6 +123,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;
@@ -141,18 +142,20 @@ static jl_array_t *_new_array_(jl_value_t *atype, uint32_t ndims, size_t *dims,
 
 static inline jl_array_t *_new_array(jl_value_t *atype, uint32_t ndims, size_t *dims)
 {
-    int isunboxed=0, elsz=sizeof(void*);
+    int isunboxed=0, elsz=sizeof(void*), elalign=JL_SMALL_BYTE_ALIGNMENT;
     jl_value_t *el_type = jl_tparam0(atype);
     isunboxed = store_unboxed(el_type);
-    if (isunboxed)
+    if (isunboxed) {
         elsz = jl_datatype_size(el_type);
-    return _new_array_(atype, ndims, dims, isunboxed, elsz);
+        elalign =jl_datatype_size(el_type);
+    }
+    return _new_array_(atype, ndims, dims, isunboxed, elsz, elalign);
 }
 
 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 NDEBUG
@@ -194,6 +197,7 @@ JL_DLLEXPORT jl_array_t *jl_reshape_array(jl_value_t *atype, jl_array_t *data,
     if (!data->flags.ptrarray) {
         a->elsize = jl_datatype_size(el_type);
         unsigned align = jl_datatype_align(el_type);
+        a->elalign = align;
         jl_value_t *ownerty = jl_typeof(owner);
         unsigned oldalign = (ownerty == (jl_value_t*)jl_string_type ? 1 :
                              jl_datatype_align(jl_tparam0(ownerty)));
@@ -205,6 +209,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;
     }
 
@@ -258,6 +263,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;
@@ -294,14 +300,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;
@@ -357,14 +364,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;
@@ -938,8 +946,9 @@ 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;
+    int elalign = ary->elalign;
     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, jl_array_len(ary) * elsz);
     return new_ary;
 }

src/dump.c

@@ -860,11 +860,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)));
@@ -1635,18 +1637,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)
@@ -1655,7 +1661,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

@@ -148,6 +148,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_datatype_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;