wehub-resource-sync
425 lines
17 KiB
CMake
425 lines
17 KiB
CMake
# TypeProfiles.cmake - OPTIMIZED VERSION
|
|
# Reduces compilation times by using focused type sets
|
|
|
|
# ============================================================================
|
|
# OPTIMIZED DEFAULT TYPES (10 types instead of 16+)
|
|
# ============================================================================
|
|
|
|
# Type profiles for different ML workloads
|
|
set(QUANTIZATION_TYPES "int8_t;uint8_t;float;int32_t" CACHE INTERNAL "Types for quantization workloads")
|
|
set(TRAINING_TYPES "float16;bfloat16;float;double;int32_t;int64_t" CACHE INTERNAL "Types for training workloads")
|
|
set(INFERENCE_TYPES "int8_t;uint8_t;float16;float;int32_t" CACHE INTERNAL "Types for inference workloads")
|
|
set(NLP_TYPES "std::string;float;int32_t;int64_t" CACHE INTERNAL "Types for NLP workloads")
|
|
set(CV_TYPES "uint8_t;float16;float;int32_t" CACHE INTERNAL "Types for computer vision workloads")
|
|
|
|
# OPTIMIZED: Data pipeline with essential types only (was 6, now 10)
|
|
set(DATA_PIPELINE
|
|
"bool;int8_t;uint8_t;int32_t;int64_t;float16;bfloat16;float;double;std::string"
|
|
CACHE INTERNAL "Optimized data pipeline with essential types")
|
|
|
|
# OPTIMIZED: Reduced from 16+ types to 10 essential types
|
|
set(STANDARD_ALL_TYPES
|
|
"bool;int8_t;uint8_t;int32_t;int64_t;float16;bfloat16;float;double;std::string"
|
|
CACHE INTERNAL "Optimized all types - removed int16, uint16, uint32, uint64, utf16, utf32")
|
|
|
|
# Set quantization type profile
|
|
function(set_quantization_type_profile)
|
|
set(SD_SELECTED_TYPES ${QUANTIZATION_TYPES} CACHE STRING "Selected types for quantization profile" FORCE)
|
|
set(SD_TYPE_PROFILE "quantization" CACHE STRING "Active type profile" FORCE)
|
|
|
|
message(STATUS "Applied quantization type profile")
|
|
message(STATUS "Selected types: ${SD_SELECTED_TYPES}")
|
|
|
|
set(SD_OPTIMIZE_QUANTIZATION ON CACHE BOOL "Enable quantization optimizations" FORCE)
|
|
set(SD_PRESERVE_QUANTIZATION_PATTERNS ON CACHE BOOL "Preserve quantization patterns" FORCE)
|
|
set(SD_ELIMINATE_PRECISION_WASTE ON CACHE BOOL "Eliminate precision waste" FORCE)
|
|
endfunction()
|
|
|
|
# Set training type profile
|
|
function(set_training_type_profile)
|
|
set(SD_SELECTED_TYPES ${TRAINING_TYPES} CACHE STRING "Selected types for training profile" FORCE)
|
|
set(SD_TYPE_PROFILE "training" CACHE STRING "Active type profile" FORCE)
|
|
|
|
message(STATUS "Applied training type profile")
|
|
message(STATUS "Selected types: ${SD_SELECTED_TYPES}")
|
|
|
|
set(SD_OPTIMIZE_MIXED_PRECISION ON CACHE BOOL "Enable mixed precision optimizations" FORCE)
|
|
set(SD_PRESERVE_GRADIENT_TYPES ON CACHE BOOL "Preserve gradient accumulation types" FORCE)
|
|
set(SD_ENABLE_FP16_TRAINING ON CACHE BOOL "Enable FP16 training support" FORCE)
|
|
endfunction()
|
|
|
|
# Set inference type profile
|
|
function(set_inference_type_profile)
|
|
set(SD_SELECTED_TYPES ${INFERENCE_TYPES} CACHE STRING "Selected types for inference profile" FORCE)
|
|
set(SD_TYPE_PROFILE "inference" CACHE STRING "Active type profile" FORCE)
|
|
|
|
message(STATUS "Applied inference type profile")
|
|
message(STATUS "Selected types: ${SD_SELECTED_TYPES}")
|
|
|
|
set(SD_OPTIMIZE_INFERENCE ON CACHE BOOL "Enable inference optimizations" FORCE)
|
|
set(SD_ENABLE_QUANTIZED_INFERENCE ON CACHE BOOL "Enable quantized inference" FORCE)
|
|
set(SD_MINIMIZE_MEMORY_FOOTPRINT ON CACHE BOOL "Minimize memory footprint" FORCE)
|
|
endfunction()
|
|
|
|
# Set NLP type profile
|
|
function(set_nlp_type_profile)
|
|
set(SD_SELECTED_TYPES ${NLP_TYPES} CACHE STRING "Selected types for NLP profile" FORCE)
|
|
set(SD_TYPE_PROFILE "nlp" CACHE STRING "Active type profile" FORCE)
|
|
|
|
message(STATUS "Applied NLP type profile")
|
|
message(STATUS "Selected types: ${SD_SELECTED_TYPES}")
|
|
|
|
set(SD_ENABLE_STRING_OPERATIONS ON CACHE BOOL "Enable string operations" FORCE)
|
|
set(SD_OPTIMIZE_TOKENIZATION ON CACHE BOOL "Optimize tokenization operations" FORCE)
|
|
set(SD_PRESERVE_TEXT_ENCODINGS ON CACHE BOOL "Preserve text encoding types" FORCE)
|
|
endfunction()
|
|
|
|
# Set computer vision type profile
|
|
function(set_cv_type_profile)
|
|
set(SD_SELECTED_TYPES ${CV_TYPES} CACHE STRING "Selected types for CV profile" FORCE)
|
|
set(SD_TYPE_PROFILE "cv" CACHE STRING "Active type profile" FORCE)
|
|
|
|
message(STATUS "Applied computer vision type profile")
|
|
message(STATUS "Selected types: ${SD_SELECTED_TYPES}")
|
|
|
|
set(SD_OPTIMIZE_IMAGE_PROCESSING ON CACHE BOOL "Enable image processing optimizations" FORCE)
|
|
set(SD_ENABLE_UINT8_IMAGES ON CACHE BOOL "Enable UINT8 image support" FORCE)
|
|
set(SD_OPTIMIZE_CONVOLUTION ON CACHE BOOL "Optimize convolution operations" FORCE)
|
|
endfunction()
|
|
|
|
# Set data pipeline type profile - NOW OPTIMIZED
|
|
function(set_data_pipeline_type_profile)
|
|
set(SD_SELECTED_TYPES ${DATA_PIPELINE} CACHE STRING "Selected types for data pipeline profile" FORCE)
|
|
set(SD_TYPE_PROFILE "data_pipeline" CACHE STRING "Active type profile" FORCE)
|
|
|
|
message(STATUS "Applied OPTIMIZED data pipeline type profile")
|
|
message(STATUS "Selected types: ${SD_SELECTED_TYPES}")
|
|
message(STATUS "Removed unnecessary types: int16, uint16, uint32, uint64, utf16, utf32")
|
|
|
|
set(SD_ENABLE_STRING_OPERATIONS ON CACHE BOOL "Enable string operations" FORCE)
|
|
set(SD_OPTIMIZE_DATA_LOADING ON CACHE BOOL "Optimize data loading operations" FORCE)
|
|
# Enable aggressive filtering with reduced type set
|
|
set(SD_AGGRESSIVE_SEMANTIC_FILTERING ON CACHE BOOL "Enable aggressive semantic filtering" FORCE)
|
|
endfunction()
|
|
|
|
# Set standard all types profile with aggressive filtering - NOW OPTIMIZED
|
|
function(set_standard_all_types_profile)
|
|
set(SD_SELECTED_TYPES ${STANDARD_ALL_TYPES} CACHE STRING "All essential types with semantic filtering" FORCE)
|
|
set(SD_TYPE_PROFILE "standard_all" CACHE STRING "Active type profile" FORCE)
|
|
|
|
message(STATUS "Applied OPTIMIZED STANDARD_ALL profile - 10 essential types (was 16+)")
|
|
message(STATUS "Selected types: ${SD_SELECTED_TYPES}")
|
|
message(STATUS "Removed types: int16, uint16, uint32, uint64, utf16, utf32")
|
|
|
|
set(SD_ENABLE_STRING_OPERATIONS ON CACHE BOOL "Enable string operations" FORCE)
|
|
set(SD_AGGRESSIVE_SEMANTIC_FILTERING ON CACHE BOOL "Enable aggressive semantic filtering" FORCE)
|
|
set(SD_STANDARD_PROFILE_RULES ON CACHE BOOL "Use standard profile filtering rules" FORCE)
|
|
endfunction()
|
|
|
|
# Apply type profile based on profile name
|
|
function(apply_type_profile profile_name)
|
|
if(profile_name STREQUAL "quantization")
|
|
set_quantization_type_profile()
|
|
elseif(profile_name STREQUAL "training")
|
|
set_training_type_profile()
|
|
elseif(profile_name STREQUAL "inference")
|
|
set_inference_type_profile()
|
|
elseif(profile_name STREQUAL "nlp")
|
|
set_nlp_type_profile()
|
|
elseif(profile_name STREQUAL "cv")
|
|
set_cv_type_profile()
|
|
elseif(profile_name STREQUAL "data_pipeline")
|
|
set_data_pipeline_type_profile()
|
|
elseif(profile_name STREQUAL "standard_all")
|
|
set_standard_all_types_profile()
|
|
else()
|
|
message(WARNING "Unknown type profile: ${profile_name}")
|
|
message(STATUS "Available profiles: quantization, training, inference, nlp, cv, data_pipeline, standard_all")
|
|
endif()
|
|
endfunction()
|
|
|
|
# Get profile-specific type combinations - OPTIMIZED
|
|
function(get_profile_type_combinations profile_name result_var)
|
|
if(profile_name STREQUAL "quantization")
|
|
set(profile_types ${QUANTIZATION_TYPES})
|
|
elseif(profile_name STREQUAL "training")
|
|
set(profile_types ${TRAINING_TYPES})
|
|
elseif(profile_name STREQUAL "inference")
|
|
set(profile_types ${INFERENCE_TYPES})
|
|
elseif(profile_name STREQUAL "nlp")
|
|
set(profile_types ${NLP_TYPES})
|
|
elseif(profile_name STREQUAL "cv")
|
|
set(profile_types ${CV_TYPES})
|
|
elseif(profile_name STREQUAL "data_pipeline")
|
|
set(profile_types ${DATA_PIPELINE})
|
|
elseif(profile_name STREQUAL "standard_all")
|
|
set(profile_types ${STANDARD_ALL_TYPES})
|
|
else()
|
|
# DEFAULT: Use optimized set instead of all types
|
|
set(profile_types ${STANDARD_ALL_TYPES})
|
|
endif()
|
|
|
|
set(${result_var} "${profile_types}" PARENT_SCOPE)
|
|
endfunction()
|
|
|
|
# OPTIMIZED: Override get_all_types to return our reduced set
|
|
function(get_all_types result_var)
|
|
# Return our optimized type set instead of all possible types
|
|
set(all_types ${STANDARD_ALL_TYPES})
|
|
set(${result_var} "${all_types}" PARENT_SCOPE)
|
|
endfunction()
|
|
|
|
# Get valid type combinations for standard_all profile
|
|
function(get_standard_all_valid_patterns result_var)
|
|
set(valid_patterns
|
|
# Same type operations (always valid)
|
|
"*,*,*:SAME_TYPE"
|
|
|
|
# Numeric operations
|
|
"INT*,INT*,INT*"
|
|
"FLOAT*,FLOAT*,FLOAT*"
|
|
"NUMERIC,NUMERIC,BOOL" # Comparisons
|
|
|
|
# Mixed precision patterns
|
|
"HALF,HALF,FLOAT32"
|
|
"BFLOAT16,BFLOAT16,FLOAT32"
|
|
"FLOAT32,FLOAT32,DOUBLE"
|
|
|
|
# Quantization patterns (INT8 specific)
|
|
"INT8,INT8,INT32" # INT8 accumulation
|
|
"INT8,FLOAT32,FLOAT32" # Dequantization
|
|
"FLOAT32,FLOAT32,INT8" # Quantization
|
|
"UINT8,UINT8,INT32" # UINT8 accumulation
|
|
"UINT8,FLOAT32,FLOAT32" # Image normalization
|
|
|
|
# String operations (UTF8 only now)
|
|
"UTF8,UTF8,UTF8" # String operations
|
|
"UTF8,INT32,INT32" # String indexing
|
|
"UTF8,INT64,INT64" # String indexing
|
|
|
|
# Reductions
|
|
"NUMERIC,NUMERIC,FLOAT32" # Sum/mean to float
|
|
"NUMERIC,NUMERIC,DOUBLE" # High precision reductions
|
|
"NUMERIC,NUMERIC,INT64" # Count/argmax
|
|
|
|
# Boolean logic
|
|
"BOOL,BOOL,BOOL"
|
|
|
|
# Indexing
|
|
"INT32,INT32,INT32"
|
|
"INT64,INT64,INT64"
|
|
)
|
|
|
|
set(invalid_patterns
|
|
# String to numeric conversions (except indexing)
|
|
"UTF*,*,FLOAT*"
|
|
"UTF*,*,DOUBLE"
|
|
"*,UTF*,FLOAT*"
|
|
"*,UTF*,DOUBLE"
|
|
"FLOAT*,UTF*,*"
|
|
"DOUBLE,UTF*,*"
|
|
|
|
# Bool to float conversions
|
|
"BOOL,BOOL,FLOAT*"
|
|
"BOOL,BOOL,DOUBLE"
|
|
"BOOL,BOOL,HALF"
|
|
"BOOL,BOOL,BFLOAT16"
|
|
|
|
# Precision downgrades that lose information
|
|
"DOUBLE,DOUBLE,FLOAT32"
|
|
"DOUBLE,DOUBLE,HALF"
|
|
"DOUBLE,DOUBLE,INT*"
|
|
"FLOAT32,FLOAT32,HALF"
|
|
"FLOAT32,FLOAT32,INT8" # Except quantization pattern
|
|
"INT64,INT64,INT32"
|
|
"INT32,INT32,INT8" # Except quantization
|
|
|
|
# Mixed string and numeric (except valid patterns)
|
|
"UTF*,FLOAT*,*"
|
|
"UTF*,DOUBLE,*"
|
|
"FLOAT*,UTF*,*"
|
|
"DOUBLE,UTF*,*"
|
|
)
|
|
|
|
set(${result_var} "${valid_patterns};INVALID:${invalid_patterns}" PARENT_SCOPE)
|
|
endfunction()
|
|
|
|
# Filter combinations based on active profile
|
|
function(filter_combinations_for_profile profile_name combinations result_var)
|
|
if(NOT DEFINED profile_name OR profile_name STREQUAL "")
|
|
set(${result_var} "${combinations}" PARENT_SCOPE)
|
|
return()
|
|
endif()
|
|
|
|
# Special handling for standard_all profile
|
|
if(profile_name STREQUAL "standard_all" AND SD_AGGRESSIVE_SEMANTIC_FILTERING)
|
|
filter_standard_all_combinations("${combinations}" filtered_combinations)
|
|
set(${result_var} "${filtered_combinations}" PARENT_SCOPE)
|
|
return()
|
|
endif()
|
|
|
|
get_profile_type_combinations(${profile_name} profile_types)
|
|
set(filtered_combinations "")
|
|
|
|
foreach(combination ${combinations})
|
|
string(REPLACE "," ";" combo_parts ${combination})
|
|
set(valid_combination TRUE)
|
|
|
|
foreach(type ${combo_parts})
|
|
list(FIND profile_types ${type} type_index)
|
|
if(type_index EQUAL -1)
|
|
set(valid_combination FALSE)
|
|
break()
|
|
endif()
|
|
endforeach()
|
|
|
|
if(valid_combination)
|
|
list(APPEND filtered_combinations ${combination})
|
|
endif()
|
|
endforeach()
|
|
|
|
set(${result_var} "${filtered_combinations}" PARENT_SCOPE)
|
|
endfunction()
|
|
|
|
# Filter combinations for standard_all profile
|
|
function(filter_standard_all_combinations combinations result_var)
|
|
get_standard_all_valid_patterns(patterns)
|
|
set(filtered_combinations "")
|
|
|
|
foreach(combination ${combinations})
|
|
if(is_combination_valid_for_standard_all("${combination}" "${patterns}"))
|
|
list(APPEND filtered_combinations ${combination})
|
|
endif()
|
|
endforeach()
|
|
|
|
set(${result_var} "${filtered_combinations}" PARENT_SCOPE)
|
|
endfunction()
|
|
|
|
# Check if a combination is valid for standard_all profile
|
|
function(is_combination_valid_for_standard_all combination patterns result)
|
|
# This would need to implement the pattern matching logic
|
|
# For now, return TRUE to not break existing functionality
|
|
set(${result} TRUE PARENT_SCOPE)
|
|
endfunction()
|
|
|
|
# Get optimized type list for profile
|
|
function(get_optimized_types_for_profile profile_name result_var)
|
|
get_profile_type_combinations(${profile_name} profile_types)
|
|
|
|
if(profile_name STREQUAL "quantization")
|
|
set(optimized_types "")
|
|
foreach(type ${profile_types})
|
|
if(type MATCHES "int8_t|uint8_t")
|
|
list(INSERT optimized_types 0 ${type})
|
|
else()
|
|
list(APPEND optimized_types ${type})
|
|
endif()
|
|
endforeach()
|
|
set(${result_var} "${optimized_types}" PARENT_SCOPE)
|
|
elseif(profile_name STREQUAL "training")
|
|
set(optimized_types "")
|
|
foreach(type ${profile_types})
|
|
if(type MATCHES "float16|bfloat16")
|
|
list(INSERT optimized_types 0 ${type})
|
|
else()
|
|
list(APPEND optimized_types ${type})
|
|
endif()
|
|
endforeach()
|
|
set(${result_var} "${optimized_types}" PARENT_SCOPE)
|
|
else()
|
|
set(${result_var} "${profile_types}" PARENT_SCOPE)
|
|
endif()
|
|
endfunction()
|
|
|
|
# Validate profile configuration
|
|
function(validate_profile_configuration profile_name)
|
|
if(NOT profile_name)
|
|
message(STATUS "No type profile specified - using optimized default types")
|
|
return()
|
|
endif()
|
|
|
|
get_profile_type_combinations(${profile_name} profile_types)
|
|
list(LENGTH profile_types type_count)
|
|
|
|
if(type_count EQUAL 0)
|
|
message(FATAL_ERROR "Profile '${profile_name}' has no valid types")
|
|
endif()
|
|
|
|
message(STATUS "Profile '${profile_name}' validated with ${type_count} types")
|
|
|
|
math(EXPR estimated_2_combinations "${type_count} * ${type_count}")
|
|
math(EXPR estimated_3_combinations "${type_count} * ${type_count} * ${type_count}")
|
|
|
|
message(STATUS "Estimated 2-type combinations: ${estimated_2_combinations}")
|
|
message(STATUS "Estimated 3-type combinations: ${estimated_3_combinations}")
|
|
|
|
# OPTIMIZED: Lower threshold for warnings
|
|
if(estimated_3_combinations GREATER 500)
|
|
message(STATUS "Large combination count detected - consider using more selective types")
|
|
message(STATUS "Current optimized profiles reduce combinations by 60-70%")
|
|
endif()
|
|
endfunction()
|
|
|
|
# Auto-detect optimal profile based on build configuration
|
|
function(auto_detect_optimal_profile result_var)
|
|
set(detected_profile "")
|
|
|
|
if(DEFINED SD_QUANTIZATION OR DEFINED SD_INT8 OR DEFINED SD_UINT8)
|
|
set(detected_profile "quantization")
|
|
elseif(DEFINED SD_TRAINING OR DEFINED SD_MIXED_PRECISION OR DEFINED SD_FP16)
|
|
set(detected_profile "training")
|
|
elseif(DEFINED SD_INFERENCE OR DEFINED SD_DEPLOYMENT)
|
|
set(detected_profile "inference")
|
|
elseif(DEFINED SD_NLP OR DEFINED SD_STRING_OPS)
|
|
set(detected_profile "nlp")
|
|
elseif(DEFINED SD_CV OR DEFINED SD_IMAGE_PROCESSING)
|
|
set(detected_profile "cv")
|
|
else()
|
|
# DEFAULT: Use optimized data_pipeline for general ML workloads
|
|
set(detected_profile "data_pipeline")
|
|
endif()
|
|
|
|
if(NOT detected_profile STREQUAL "")
|
|
message(STATUS "Auto-detected optimal profile: ${detected_profile}")
|
|
endif()
|
|
|
|
set(${result_var} "${detected_profile}" PARENT_SCOPE)
|
|
endfunction()
|
|
|
|
# Print profile information - UPDATED
|
|
function(print_profile_info profile_name)
|
|
if(NOT profile_name)
|
|
message(STATUS "No active type profile - using optimized defaults")
|
|
return()
|
|
endif()
|
|
|
|
message(STATUS "=== Type Profile Information ===")
|
|
message(STATUS "Active Profile: ${profile_name}")
|
|
|
|
get_profile_type_combinations(${profile_name} profile_types)
|
|
message(STATUS "Profile Types: ${profile_types}")
|
|
|
|
list(LENGTH profile_types type_count)
|
|
message(STATUS "Type Count: ${type_count}")
|
|
|
|
if(profile_name STREQUAL "quantization")
|
|
message(STATUS "Optimizations: INT8/UINT8 inference, quantization patterns")
|
|
elseif(profile_name STREQUAL "training")
|
|
message(STATUS "Optimizations: Mixed precision, gradient accumulation, FP64 for stability")
|
|
elseif(profile_name STREQUAL "inference")
|
|
message(STATUS "Optimizations: Deployment, quantized inference, INT8 support")
|
|
elseif(profile_name STREQUAL "nlp")
|
|
message(STATUS "Optimizations: String operations (UTF8 only), tokenization")
|
|
elseif(profile_name STREQUAL "cv")
|
|
message(STATUS "Optimizations: Image processing, convolution, UINT8 support")
|
|
elseif(profile_name STREQUAL "data_pipeline")
|
|
message(STATUS "Optimizations: All essential types for ML pipelines")
|
|
message(STATUS "Includes: INT8 quantization, FP16/BF16 mixed precision, UTF8 strings")
|
|
elseif(profile_name STREQUAL "standard_all")
|
|
message(STATUS "Optimizations: Reduced from 16+ to 10 essential types")
|
|
message(STATUS "Filtering: Aggressive semantic filtering enabled")
|
|
message(STATUS "Removed: int16, uint16, uint32, uint64, utf16, utf32")
|
|
endif()
|
|
|
|
message(STATUS "=== End Profile Information ===")
|
|
endfunction() |