accumulated improvements

Author: decarvalhojunior-fh

src/PlatformAware.jl

@@ -57,7 +57,7 @@ export
     @just,
     @unlimited,
     @api,
-    PlatformFeature,
+    PlatformType,
     QuantifierFeature,
     QualifierFeature,
     Query,

src/features/default/Platform.toml

@@ -7,7 +7,6 @@
 
 [node]
 
-node_count = 1
 node_provider = "OnPremise"
 node_virtual = "No"
 node_dedicated = "Yes"  

src/features/detection.jl

@@ -484,9 +484,9 @@ function identifyProcessor()
          get!(cdict,c[:id],c[:value])
       end
       processor_core_count = parse(Int64,cdict["enabledcores"])
-      processor_core_threadscount = parse(Int64,cdict["threads"])
+      processor_core_threads_count = parse(Int64,cdict["threads"])
 
-      push!(l,(p["product"],processor_core_count, processor_core_threadscount,lc))
+      push!(l,(p["product"],processor_core_count, processor_core_threads_count,lc))
        
    end
 
@@ -784,17 +784,17 @@ function identifyNode()
    println(stderr, "=> Note: detection of node features (cluster and cloud computing) not yet implemented. Using default features.")
    println(stderr, "         You can setup node features manually.")
 
-   interconnection_features = Dict()
+   node_features = Dict()
 
-   interconnection_features["node_count"] = 1
-   interconnection_features["node_provider"] = "OnPremise"
-   interconnection_features["node_virtual"] = "No"
-   interconnection_features["node_dedicated"] = "No"
-   interconnection_features["node_machinefamily"] = "unset"
-   interconnection_features["node_machinetype"] = "unset"
-   interconnection_features["node_vcpus_count"] = "unset"
+   node_features["node_count"] = 1
+   node_features["node_provider"] = "OnPremise"
+   node_features["node_virtual"] = "No"
+   node_features["node_dedicated"] = "No"
+   node_features["node_machinefamily"] = "unset"
+   node_features["node_machinetype"] = "unset"
+   node_features["node_vcpus_count"] = "unset"
 
-   return interconnection_features
+   return node_features
 end
 
 function addNodeFeatures!(platform_features, node_features)

src/features/features.jl

@@ -2,10 +2,10 @@
 # Licensed under the MIT License. See LICENCE in the project root.
 # ------------------------------------------------------------------
 
-abstract type PlatformFeature end
+abstract type PlatformType end
 
-abstract type QuantifierFeature <: PlatformFeature end
-abstract type QualifierFeature <: PlatformFeature end
+abstract type QuantifierFeature <: PlatformType end
+abstract type QualifierFeature <: PlatformType end
 
 @enum FeatureType qualifier=1 api_qualifier quantifier
 
@@ -22,6 +22,7 @@ global feature_type = Dict(
     :node_memory_bandwidth => quantifier,
     :node_memory_type => qualifier,
     :node_memory_frequency => quantifier,
+    :node_coworker_count => qualifier,
     :processor_count => quantifier,
     :processor_manufacturer => qualifier,
     :processor_microarchitecture => qualifier,
@@ -165,15 +166,15 @@ function get_qualifier(feature)
     getfield(@__MODULE__, Meta.parse(feature))
 end
 
-function check_blank_feature(parameter_id, feature, default_platform_types)
+function check_blank_feature(parameter_id, feature, platform_feature_default)
     if (feature == "na")
-        default_platform_types[parameter_id]
+        platform_feature_default[parameter_id]
     elseif (feature == "unset")
-        default_platform_types[parameter_id]
+        platform_feature_default[parameter_id]
     elseif (feature == "unknown")
-        default_platform_types[parameter_id]
+        platform_feature_default[parameter_id]
     elseif (feature == "ignore")
-        default_platform_types[parameter_id]
+        platform_feature_default[parameter_id]
     else
         nothing
     end
@@ -203,7 +204,7 @@ function identifyAPI_oldversion(api_string)
 
  end
 
-function get_api_qualifier(api_string, default_platform_types)
+function get_api_qualifier(api_string, platform_feature_default)
 
     apis = split(api_string,';')
 
@@ -224,27 +225,27 @@ function get_api_qualifier(api_string, default_platform_types)
 
  end
 
-function loadFeaturesSection!(dict, actual_platform_arguments, default_platform_types)
+function loadFeaturesSection!(dict, platform_feature, platform_feature_default)
 
     if ("0" in keys(dict))
         dict = dict["0"]
     end
 
     for (parameter_id, feature) in dict
         p = Meta.parse(parameter_id)
-        v0 = check_blank_feature(p, feature, default_platform_types)
+        v0 = check_blank_feature(p, feature, platform_feature_default)
         v = if (isnothing(v0))
-                feature_type[p] == qualifier ? get_qualifier(feature) :  feature_type[p] == api_qualifier ? get_api_qualifier(feature, default_platform_types) : get_quantifier(feature) 
+                feature_type[p] == qualifier ? get_qualifier(feature) :  feature_type[p] == api_qualifier ? get_api_qualifier(feature, platform_feature_default) : get_quantifier(feature) 
             else
                 v0
             end
-        actual_platform_arguments[p]= v
+        platform_feature[p]= v
     end
 end
 
-function loadFeatures!(dict, default_platform_types, actual_platform_arguments)
+function loadFeatures!(dict, platform_feature_default, platform_feature)
     loadDBs!()
     for key in ["node", "processor", "accelerator", "memory", "storage", "interconnection"]
-        loadFeaturesSection!(dict[key], actual_platform_arguments, default_platform_types) 
+        loadFeaturesSection!(dict[key], platform_feature, platform_feature_default) 
     end
 end

src/features/qualifiers/amd/db-processors.AMD.csv

@@ -1,4 +1,4 @@
-,,processor_core_count,processor_clock,processor_core_threadscount,processor_isa,processor_simd,processor_microarchitecture,processor,processor_manufacturer,processor_tdp,processor_core_L1_size,processor_core_L2_size,processor_L3_size,node_memory_bandwidth,node_memory_type
+,,processor_core_count,processor_clock,processor_core_threads_count,processor_isa,processor_simd,processor_microarchitecture,processor,processor_manufacturer,processor_tdp,processor_core_L1_size,processor_core_L2_size,processor_L3_size,node_memory_bandwidth,node_memory_type
 AMD;Turion,TL64,2,2.2G,2,64-bit,MMX;Now3Dx;SSE;SSE2;SSE3,unset,AMDTurion_TL64,AMD,35,unset,1MB,unset,667M,DDR2
 AMD;Turion,TL60,2,2.0G,2,64-bit,MMX;Now3Dx;SSE;SSE2;SSE3,unset,AMDTurion_TL60,AMD,31,unset,1MB,unset,667M,DDR2
 AMD;Turion,TL56,2,1.8G,2,64-bit,MMX;Now3Dx;SSE;SSE2;SSE3,unset,AMDTurion_TL56,AMD,31,unset,unset,unset,unset,unset

src/features/qualifiers/common.jl

@@ -113,7 +113,16 @@ abstract type ISA_x86_64_v4 <: ISA_x86_64_v3 end
 
 abstract type ISA_IA_64 <: ProcessorISA end
 
-
 export ISA_x86_32, ISA_x86, ISA_x86_64, ISA_AMD_64, ISA_x86_64_v1, ISA_x86_64_v2, ISA_x86_64_v3, ISA_x86_64_v4, ISA_IA_64
 
 
+abstract type WorkerCount end
+abstract type NoCoworkers <: WorkerCount end
+abstract type PerNode <: WorkerCount end
+abstract type PerProcessor <: WorkerCount end
+abstract type PerCore <: WorkerCount end
+abstract type PerThread <: WorkerCount end
+abstract type PerVCPU <: WorkerCount end
+abstract type Unmapped <: WorkerCount end
+
+export PerNode, PerProcessor, PerCore, PerThread, PerVCPU

src/features/qualifiers/ec2/ec2.jl

@@ -19,7 +19,7 @@ abstract type EC2Family_Memory <: EC2Family end
 abstract type EC2Family_Storage <: EC2Family end
 
 # machine type types and sizes
- 
+
 abstract type EC2Type <: MachineType end
 
 

src/features/qualifiers/intel/db-processors.Intel.csv

@@ -1,4 +1,4 @@
-,,processor_core_count,processor_clock,processor_core_threadscount,processor_isa,processor_simd,processor_microarchitecture,processor,processor_manufacturer,processor_tdp,processor_core_L1_size,processor_core_L2_size,processor_L3_size
+,,processor_core_count,processor_clock,processor_core_threads_count,processor_isa,processor_simd,processor_microarchitecture,processor,processor_manufacturer,processor_tdp,processor_core_L1_size,processor_core_L2_size,processor_L3_size
 Intel;Xeon;W,3275M,28,2.50G,56,64-bit,AVX-512,CascadeLake,IntelXeon_W_3275M,Intel,205,unset,unset,unset
 Intel;Xeon;W,3265M,24,2.70G,48,64-bit,AVX-512,CascadeLake,IntelXeon_W_3265M,Intel,205,unset,unset,unset
 Intel;Xeon;W,3245M,16,3.20G,32,64-bit,AVX-512,CascadeLake,IntelXeon_W_3245M,Intel,205,unset,unset,unset

src/platform.jl

@@ -3,10 +3,10 @@
 # ------------------------------------------------------------------
 
 mutable struct PlatformFeatures
-    default_platform_types_all
-    default_platform_types
-    actual_platform_arguments_all
-    actual_platform_arguments    
+    platform_feature_default_all
+    platform_feature_default
+    platform_feature_all
+    platform_feature    
     function PlatformFeatures()
         new(Dict(),Dict(),Dict(),Dict())
     end
@@ -28,6 +28,7 @@ defT =[
     :node_memory_bandwidth => Tuple{AtLeast0,AtMostInf},
     :node_memory_type => MemoryType,
     :node_memory_frequency => Tuple{AtLeast1,AtMostInf},
+    :node_coworker_count => WorkerCount, # number of worker processes (i.e., julia -p N)
     :processor_count => Tuple{AtLeast1,AtMostInf},
     :processor_manufacturer => Manufacturer,
     :processor_microarchitecture => ProcessorMicroarchitecture,
@@ -78,63 +79,101 @@ defT =[
     :storage_interface => StorageInterface
 ]
 
-state.default_platform_types_all = Dict(defT...)
-state.default_platform_types = copy(state.default_platform_types_all)
+state.platform_feature_default_all = Dict(defT...)
+state.platform_feature_default = copy(state.platform_feature_default_all)
+
+function setupWorkers(platform_description_dict, platform_feature)
+    try
+        colocated_procs = procs(myid())
+
+        node_coworker_count = if (1 in colocated_procs)
+                                 length(colocated_procs) - 1
+                              else
+                                 length(colocated_procs)
+                              end
+
+        vcount = platform_description_dict[:node_vcpus_count]
+        pcount = platform_description_dict[:processor_count]
+        ccount = pcount * platform_description_dict[:processor_core_count]
+        tcount = ccount * platform_description_dict[:processor_core_threads_count]
+
+        if vcount == node_coworker_count && platform_description_dict[:maintainer] == CloudProvider
+            platform_feature[:node_coworker_count] = PerVCPU
+        elseif (node_coworker_count = 0)
+            platform_feature[:node_coworker_count] = NoCoworkers
+        elseif node_coworker_count == 1
+            platform_feature[:node_coworker_count] = PerNode
+        elseif pcount == node_coworker_count
+            platform_feature[:node_coworker_count] = PerProcessor
+        elseif ccount == node_coworker_count
+            platform_feature[:node_coworker_count] = PerCore
+        elseif tcount == node_coworker_count
+            platform_feature[:node_coworker_count] = PerThread
+        else
+            platform_feature[:node_coworker_count] = Unmapped
+        end
+    catch _
+        platform_feature[:node_coworker_count] = NoCoworkers
+    end
+end
 
 function load!()
-    empty!(state.actual_platform_arguments_all)
+    empty!(state.platform_feature_all)
     platform_description_dict = readPlatormDescription()
-    loadFeatures!(platform_description_dict, state.default_platform_types_all, state.actual_platform_arguments_all)
+    platform_description_dict["node"]["node_count"] = try Distributed.nworkers() catch _ 1 end
+    loadFeatures!(platform_description_dict, state.platform_feature_default_all, state.platform_feature_all)
+
+    setupWorkers(platform_description_dict, state.platform_feature_all)
 
-    empty!(state.actual_platform_arguments)
-    for (k,v) in state.actual_platform_arguments_all
-        state.actual_platform_arguments[k] = v
+    empty!(state.platform_feature)
+    for (k,v) in state.platform_feature_all
+        state.platform_feature[k] = v
     end
 end
 
 # load!()
 
 function setplatform!(parameter_id, actual_type)
-    state.actual_platform_arguments[parameter_id] = actual_type
+    state.platform_feature[parameter_id] = actual_type
     (parameter_id,actual_type)
 end
 
 function getplatform(parameter_id)
-    state.actual_platform_arguments[parameter_id]
+    state.platform_feature[parameter_id]
 end
 
 function getplatform()
-    state.actual_platform_arguments
+    state.platform_feature
 end
 
-function empty_actual_platform_arguments!()
-    empty!(state.actual_platform_arguments)
-    empty!(state.default_platform_types)
+function empty_platform_feature!()
+    empty!(state.platform_feature)
+    empty!(state.platform_feature_default)
 end
 
-function reset_actual_platform_arguments!()
-    for (k,v) in state.actual_platform_arguments_all
-        state.actual_platform_arguments[k] = v
+function reset_platform_feature!()
+    for (k,v) in state.platform_feature_all
+        state.platform_feature[k] = v
     end
     for (k,v) in platform_types_all
-        state.default_platform_types[k] = v
+        state.platform_feature_default[k] = v
     end
-    keys(state.actual_platform_arguments)
+    keys(state.platform_feature)
 end
 
 function include_actual_platform_argument!(f)
-    state.actual_platform_arguments[f] = state.actual_platform_arguments_all[f]
-    state.default_platform_types[f] = state.default_platform_types_all[f]
-    keys(state.actual_platform_arguments)
+    state.platform_feature[f] = state.platform_feature_all[f]
+    state.platform_feature_default[f] = state.platform_feature_default_all[f]
+    keys(state.platform_feature)
 end
 
 
 function platform_parameter_macro!(f)
 
     if (f == :clear)
-        empty_actual_platform_arguments!()
+        empty_platform_feature!()
     elseif (f == :all)
-        reset_actual_platform_arguments!()
+        reset_platform_feature!()
     else
         check_all(f)
         include_actual_platform_argument!(f)
@@ -149,24 +188,24 @@ function platform_parameters_kernel(p_list)
 
     # replace default types to required types in kernel platform parameters
     r = []
-    for k in keys(state.actual_platform_arguments)
+    for k in keys(state.platform_feature)
          found = get(p_dict, k, nothing)
-         v = state.default_platform_types[k]
+         v = state.platform_feature_default[k]
          push!(r, isnothing(found) ? :(::Type{<:$v}) : :(::Type{<:$found}))
     end
 
     return r
 end
 
 function check_all(parameter_id)
-    if (!haskey(state.actual_platform_arguments_all,parameter_id))
+    if (!haskey(state.platform_feature_all,parameter_id))
         throw(parameter_id)
     end
     parameter_id
 end
 
 function check(parameter_id)
-    if (!haskey(state.actual_platform_arguments,parameter_id))
+    if (!haskey(state.platform_feature,parameter_id))
         throw(parameter_id)
     end
     parameter_id
@@ -225,7 +264,7 @@ function build_entry_signature(fsign::Expr)
     keyword_parameters = length(call_node_args) > 1 && typeof(call_node_args[1]) == Expr && call_node_args[1].head == :parameters ? popfirst!(call_node_args).args : []
     # takes a dictionary mapping par->actual_type and returns an expression :(par::actual_type)
     # the remaining elements in call_node_args are the kernel parameters.
-    platform_parameters = map(p->Expr(:kw,Expr(:(::),p[1],Type{<:state.default_platform_types[p[1]]}),p[2]), collect(state.actual_platform_arguments))
+    platform_parameters = map(p->Expr(:kw,Expr(:(::),p[1],Type{<:state.platform_feature_default[p[1]]}),p[2]), collect(state.platform_feature))
     # rebuild the keyword parameters node for the entry function, including the platform_parameters
     keyword_parameters_node = Expr(:parameters, platform_parameters..., keyword_parameters...)
     # collect the identifiers of the kernel parameters
@@ -239,7 +278,7 @@ end
 
 function build_entry_body(fname, fargs, kargs)
     # takes the identifiers of the platform parameters
-    pargs = keys(state.actual_platform_arguments)
+    pargs = keys(state.platform_feature)
     # builds the :parameters node for the keyword arguments of the kernel invocation (kargs), since the identifiers must be refferenced.
     kargs = Expr(:parameters, map(p -> Expr(:kw, p, p), kargs)...)
     # returns the :call node for the kernel invocation (note that platform arguments comes before kernel arguments)