add back jl_gc_alignment for now

Author: vchuravy

base/atomics.jl

@@ -2,7 +2,7 @@
 
 using Core.Intrinsics: llvmcall
 
-import Base: setindex!, getindex, unsafe_convert, datatype_alignment
+import Base: setindex!, getindex, unsafe_convert
 import Base.Sys: ARCH, WORD_SIZE
 
 export
@@ -332,6 +332,9 @@ inttype(::Type{Float16}) = Int16
 inttype(::Type{Float32}) = Int32
 inttype(::Type{Float64}) = Int64
 
+
+alignment(::Type{T}) where {T} = ccall(:jl_alignment, Cint, (Csize_t,), sizeof(T))
+
 # All atomic operations have acquire and/or release semantics, depending on
 # whether the load or store values. Most of the time, this is what one wants
 # anyway, and it's only moderately expensive on most hardware.
@@ -343,13 +346,13 @@ for typ in atomictypes
     @eval getindex(x::Atomic{$typ}) =
         llvmcall($"""
                  %ptr = inttoptr i$WORD_SIZE %0 to $lt*
-                 %rv = load atomic $rt %ptr acquire, align $(datatype_alignment(typ))
+                 %rv = load atomic $rt %ptr acquire, align $(alignment(typ))
                  ret $lt %rv
                  """, $typ, Tuple{Ptr{$typ}}, unsafe_convert(Ptr{$typ}, x))
     @eval setindex!(x::Atomic{$typ}, v::$typ) =
         llvmcall($"""
                  %ptr = inttoptr i$WORD_SIZE %0 to $lt*
-                 store atomic $lt %1, $lt* %ptr release, align $(datatype_alignment(typ))
+                 store atomic $lt %1, $lt* %ptr release, align $(alignment(typ))
                  ret void
                  """, Void, Tuple{Ptr{$typ}, $typ}, unsafe_convert(Ptr{$typ}, x), v)
 

src/julia_internal.h

@@ -192,6 +192,28 @@ static const int jl_gc_sizeclasses[JL_GC_N_POOLS] = {
 //    64,   32,  160,   64,   16,   64,  112,  128, bytes lost
 };
 
+STATIC_INLINE int jl_gc_alignment(size_t sz)
+{
+    if (sz == 0)
+        return sizeof(void*);
+#ifdef _P64
+    (void)sz;
+    return 16;
+#elif defined(_CPU_ARM_) || defined(_CPU_PPC_)
+    return sz <= 4 ? 8 : 16;
+#else
+    // szclass 8
+    if (sz <= 4)
+        return 8;
+    // szclass 12
+    if (sz <= 8)
+        return 4;
+    // szclass 16+
+    return 16;
+#endif
+}
+JL_DLLEXPORT int jl_alignment(size_t sz);
+
 STATIC_INLINE size_t JL_CONST_FUNC jl_gc_alignsz(size_t sz, size_t alignment)
 {
     // The pools are aligned with JL_HEAP_ALIGNMENT and no bigger alignment is possible.

src/threading.c

@@ -820,6 +820,14 @@ void jl_init_threading(void)
 void jl_start_threads(void) { }
 
 #endif // !JULIA_ENABLE_THREADING
+
+// Make gc alignment available for threading
+// see threads.jl alignment
+JL_DLLEXPORT int jl_alignment(size_t sz)
+{
+    return jl_gc_alignment(sz);
+}
+
 #ifdef __cplusplus
 }
 #endif