Format coded according to JuliaFormatter

Author: el-oso

src/CPUSummary.jl

@@ -1,14 +1,13 @@
 module CPUSummary
-if isdefined(Base, :Experimental) &&
-        isdefined(Base.Experimental, Symbol("@max_methods"))
-    @eval Base.Experimental.@max_methods 1
+if isdefined(Base, :Experimental) && isdefined(Base.Experimental, Symbol("@max_methods"))
+  @eval Base.Experimental.@max_methods 1
 end
 
 using Static
 using Static: Zero, One, gt, lt
 using IfElse: ifelse
 export cache_size,
-    cache_linesize, cache_associativity, cache_type, cache_inclusive, num_cache, num_cores
+  cache_linesize, cache_associativity, cache_type, cache_inclusive, num_cache, num_cores
 
 # const USE_HWLOC = @load_preference("hwloc", Sys.ARCH !== :aarch64 || !Sys.isapple())
 # use_hwloc(b) = @set_preferences!("hwloc" => b)
@@ -41,16 +40,16 @@ Returns the cache size per core of the `N`th cache
 function cache_size end
 
 function get_cpu_threads()::Int
-    if isdefined(Sys, :CPU_THREADS)
-        return Sys.CPU_THREADS
-    else
-        return Int(ccall(:jl_cpu_threads, Int32, ()))::Int
-    end
+  if isdefined(Sys, :CPU_THREADS)
+    return Sys.CPU_THREADS
+  else
+    return Int(ccall(:jl_cpu_threads, Int32, ()))::Int
+  end
 end
 if (Sys.ARCH === :x86_64)
-    include("x86.jl")
+  include("x86.jl")
 else
-    include("generic_topology.jl")
+  include("generic_topology.jl")
 end
 # function __init__()
 #   ccall(:jl_generating_output, Cint, ()) == 1 && return
@@ -71,28 +70,28 @@ end
 
 
 # end
-num_cache(::Union{Val{1}, StaticInt{1}}) = num_l1cache()
-num_cache(::Union{Val{2}, StaticInt{2}}) = num_l2cache()
-num_cache(::Union{Val{3}, StaticInt{3}}) = num_l3cache()
-num_cache(::Union{Val{4}, StaticInt{4}}) = num_l4cache()
+num_cache(::Union{Val{1},StaticInt{1}}) = num_l1cache()
+num_cache(::Union{Val{2},StaticInt{2}}) = num_l2cache()
+num_cache(::Union{Val{3},StaticInt{3}}) = num_l3cache()
+num_cache(::Union{Val{4},StaticInt{4}}) = num_l4cache()
 const BASELINE_CORES = Int(num_cores()) * ((Sys.ARCH === :aarch64) && Sys.isapple() ? 2 : 1)
 cache_linesize() = cache_linesize(Val(1))
 function num_cache_levels()
-    numl4 = num_l4cache()
-    numl4 === nothing && return nothing
-    return ifelse(
-        eq(numl4, Zero()),
-        ifelse(
-            eq(num_l3cache(), Zero()),
-            ifelse(
-                eq(num_l2cache(), Zero()),
-                ifelse(eq(num_l1cache(), Zero()), Zero(), One()),
-                StaticInt{2}(),
-            ),
-            StaticInt{3}(),
-        ),
-        StaticInt{4}(),
-    )
+  numl4 = num_l4cache()
+  numl4 === nothing && return nothing
+  return ifelse(
+    eq(numl4, Zero()),
+    ifelse(
+      eq(num_l3cache(), Zero()),
+      ifelse(
+        eq(num_l2cache(), Zero()),
+        ifelse(eq(num_l1cache(), Zero()), Zero(), One()),
+        StaticInt{2}(),
+      ),
+      StaticInt{3}(),
+    ),
+    StaticInt{4}(),
+  )
 end
 
 # explicit precompilation only on Julia v1.9 and newer

src/generic_topology.jl

@@ -35,14 +35,16 @@ end
 cache_associativity(::Union{Val{2},StaticInt{2}}) = StaticInt{0}()
 cache_type(::Union{Val{2},StaticInt{2}}) = Val{:Unified}()
 cache_inclusive(_) = False()
-@static if Sys.ARCH === :aarch64 && (Sys.isapple() || occursin("apple", Sys.CPU_NAME::String))
+@static if Sys.ARCH === :aarch64 &&
+           (Sys.isapple() || occursin("apple", Sys.CPU_NAME::String))
   cache_linesize(_) = StaticInt{128}() # assume...
 else
   cache_linesize(_) = StaticInt{64}() # assume...
 end
 cache_size(_) = StaticInt{0}()
 
-@static if Sys.ARCH === :aarch64 && (Sys.isapple() || occursin("apple", Sys.CPU_NAME::String))
+@static if Sys.ARCH === :aarch64 &&
+           (Sys.isapple() || occursin("apple", Sys.CPU_NAME::String))
 else
   cache_type(::Union{Val{3},StaticInt{3}}) = Val{:Unified}()
   cache_size(::Union{Val{3},StaticInt{3}}) = StaticInt{1441792}()

src/x86.jl

@@ -6,18 +6,18 @@ num_sockets() = static(1)
 _get_num_cores()::Int = clamp(CpuId.cpucores(), 1, (get_cpu_threads())::Int)
 
 let nc = static(_get_num_cores())
-    global num_l1cache() = nc
-    global num_cores() = nc
+  global num_l1cache() = nc
+  global num_cores() = nc
 end
 let syst = static((get_cpu_threads())::Int)
-    global sys_threads() = syst
+  global sys_threads() = syst
 end
 num_l2cache() = num_l1cache()
 num_l3cache() = static(1)
 num_l4cache() = static(0)
 
 const PrecompiledCacheSize = let cs = CpuId.cachesize()
-    ntuple(i -> i == 3 ? cs[3] ÷ _get_num_cores() : cs[i], length(cs))
+  ntuple(i -> i == 3 ? cs[3] ÷ _get_num_cores() : cs[i], length(cs))
 end
 const PrecompiledCacheInclusive = CpuId.cacheinclusive()
 # cache_inclusive(_) = False()
@@ -39,52 +39,52 @@ cache_size(::Val{S}) where {S} = cache_size(S)
 cache_size(::StaticInt{S}) where {S} = cache_size(S)
 
 @inline @generated function cache_size(cachesize)
-    cs = let cs = CpuId.cachesize()
-        ntuple(i -> i == 3 ? cs[3] ÷ _get_num_cores() : cs[i], length(cs))
-    end
+  cs = let cs = CpuId.cachesize()
+    ntuple(i -> i == 3 ? cs[3] ÷ _get_num_cores() : cs[i], length(cs))
+  end
 
-    cache_sizes = map(enumerate(cs)) do (i, csi)
+  cache_sizes = map(enumerate(cs)) do (i, csi)
 
-        return :(
-            if cachesize == $i
-                return static($csi)
-            end
-        )
-    end
+    return :(
+      if cachesize == $i
+        return static($csi)
+      end
+    )
+  end
 
-    return quote
-        begin
-            $(cache_sizes...)
-        end
+  return quote
+    begin
+      $(cache_sizes...)
     end
+  end
 
 end
 cache_inclusive(::Val{S}) where {S} = cache_inclusive(S)
 cache_inclusive(::StaticInt{S}) where {S} = cache_inclusive(S)
 
 @inline @generated function cache_inclusive(cacheinclusive)
-    ci = CpuId.cacheinclusive()
-
-    cache_inclusives = map(enumerate(ci)) do (i, cii)
-        val = cii != 0
-        return :(
-            if cacheinclusive == $i
-                return static($val)
-            end
-        )
-    end
-
-    if !isempty(cache_inclusives)
-        push!(cache_inclusives, :(return False()))
-    else
-        cache_inclusives = [:(return False())]
-    end
-
-    return quote
-        begin
-            $(cache_inclusives...)
-        end
+  ci = CpuId.cacheinclusive()
+
+  cache_inclusives = map(enumerate(ci)) do (i, cii)
+    val = cii != 0
+    return :(
+      if cacheinclusive == $i
+        return static($val)
+      end
+    )
+  end
+
+  if !isempty(cache_inclusives)
+    push!(cache_inclusives, :(return False()))
+  else
+    cache_inclusives = [:(return False())]
+  end
+
+  return quote
+    begin
+      $(cache_inclusives...)
     end
+  end
 
 
 end
@@ -93,22 +93,22 @@ end
 # TODO: implement
 cache_associativity(_) = static(0)
 
-cache_type(::Union{Val{1}, StaticInt{1}}) = Val{:Data}()
+cache_type(::Union{Val{1},StaticInt{1}}) = Val{:Data}()
 cache_type(_) = Val{:Unified}()
 # cache_type(::Union{Val{2},StaticInt{2}}) = Val{:Unified}()
 # cache_type(::Union{Val{3},StaticInt{3}}) = Val{:Unified}()
 let lnsize = static(CpuId.cachelinesize())
-    global cache_linesize(_) = lnsize
+  global cache_linesize(_) = lnsize
 end
 # cache_size(_) = StaticInt{0}()
 
 # cache_size(::Union{Val{3},StaticInt{3}}) = num_cores() * StaticInt{1441792}()
 function _extra_init()
-    cs = let cs = CpuId.cachesize()
-        ntuple(i -> i == 3 ? cs[3] ÷ _get_num_cores() : cs[i], length(cs))
-    end
-    cs !== PrecompiledCacheSize && _eval_cache_size(cs)
-    ci = CpuId.cacheinclusive()
-    ci !== PrecompiledCacheInclusive && _eval_cache_inclusive(ci)
-    return nothing
+  cs = let cs = CpuId.cachesize()
+    ntuple(i -> i == 3 ? cs[3] ÷ _get_num_cores() : cs[i], length(cs))
+  end
+  cs !== PrecompiledCacheSize && _eval_cache_size(cs)
+  ci = CpuId.cacheinclusive()
+  ci !== PrecompiledCacheInclusive && _eval_cache_inclusive(ci)
+  return nothing
 end