ROCm CI Service Account
508 строки
24 KiB
C++
508 строки
24 KiB
C++
/*
|
||
Copyright (c) 2023 Advanced Micro Devices, Inc. All rights reserved.
|
||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||
of this software and associated documentation files (the "Software"), to deal
|
||
in the Software without restriction, including without limitation the rights
|
||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sindxl
|
||
copies of the Software, and to permit persons to whom the Software is
|
||
furnished to do so, subject to the following conditions:
|
||
The above copyright notice and this permission notice shall be included in
|
||
all copies or substantial portions of the Software.
|
||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||
THE SOFTWARE.
|
||
*/
|
||
|
||
/*
|
||
This file has definition of functions for the following functinality:
|
||
|
||
1) get_combi_string_vec() : Retrieve the combination string which contains
|
||
contains the combination of block name which indicate the respective compiler
|
||
option seperated by ':' from RtcConfig.jason file and returns them in the
|
||
form of vectors.
|
||
|
||
2) split_comb_string() : The combination of blockname which are seperated by
|
||
':' has to split so that their respective compiler option can be retrieved
|
||
from the json file. This functn internally calls calling_combination_function()
|
||
for each of the combination of compiler options. This function returns a
|
||
int value i.e the total failed cases in that combination which is obtained
|
||
by calling_combination_function() function.
|
||
|
||
3) calling_combination_function() : This function takes the combination of
|
||
blockname as the input. The respective compiler option for that block name is
|
||
retrieved from the json file and store the compiler options in a array.
|
||
calling_resp_function() is called which mapps the compiler option function
|
||
which has to be called with a set of required parameters
|
||
(combination of compiler options is one among them). this function returns
|
||
the status of execution ie 1 or 0 (bool).
|
||
|
||
4) getblock_fromconfig() : This function is used to open the RtcConfig.json
|
||
file and return the blocks.
|
||
|
||
5) get_string_parameters() and get_array_parameters() : retrieved the
|
||
parameters of the respective block name.
|
||
|
||
*/
|
||
|
||
#include <hip/hiprtc.h>
|
||
#include <hip/hip_runtime.h>
|
||
#include <picojson.h>
|
||
#include <vector>
|
||
#include <string>
|
||
#include <fstream>
|
||
#include <iostream>
|
||
#include "headers/RtcUtility.h"
|
||
#include "headers/RtcFunctions.h"
|
||
#include "headers/RtcKernels.h"
|
||
#include <hip_test_common.hh>
|
||
#include "headers/printf_common.h"
|
||
|
||
std::vector<std::string> get_combi_string_vec() {
|
||
picojson::array combi_string = get_array_parameters("Combi_CO",
|
||
"all_compier_options");
|
||
std::vector<std::string> combi_string_list;
|
||
for (auto& indx : combi_string) {
|
||
combi_string_list.push_back(indx.get<std::string>());
|
||
}
|
||
return combi_string_list;
|
||
}
|
||
|
||
int split_comb_string(std::string option) {
|
||
int start_collon_index = option.find(':');
|
||
int start_index = 0;
|
||
std::vector<std::string> combi_block_name;
|
||
while (start_collon_index != std::string::npos) {
|
||
std::string singleoption = option.substr(start_index,
|
||
start_collon_index - start_index);
|
||
combi_block_name.push_back(singleoption);
|
||
start_index = start_collon_index + 1;
|
||
start_collon_index = option.find(':', start_index);
|
||
}
|
||
std::string last_option = option.substr(start_index,
|
||
option.length() - start_index);
|
||
combi_block_name.push_back(last_option);
|
||
return calling_combination_function(combi_block_name);
|
||
}
|
||
|
||
int calling_combination_function(std::vector<std::string> combi_vec_list) {
|
||
int combi_size = combi_vec_list.size();
|
||
int fast_math_present = -1, undef_present = 0;
|
||
int a = 0;
|
||
int max_thread_position;
|
||
std::string hold_CO[combi_size];
|
||
const char** Combination_CO = new const char*[combi_size];
|
||
picojson::array undef_compiler_option = get_array_parameters(
|
||
"compiler_option", "undef_macro");
|
||
std::vector<std::string> undef_CO_vec;
|
||
for (auto& indx : undef_compiler_option) {
|
||
undef_CO_vec.push_back(indx.get<std::string>());
|
||
}
|
||
for (int i=0; i< combi_size; i++) {
|
||
if (combi_vec_list[i] == "max_thread") {
|
||
std::string ready_CO = get_string_parameters("ready_compiler_option",
|
||
combi_vec_list[i]);
|
||
hold_CO[i] = ready_CO;
|
||
if (combi_vec_list[i] == "max_thread") {
|
||
max_thread_position = i;
|
||
}
|
||
} else if (combi_vec_list[i] == "header_dir") {
|
||
std::string retrived_CO = get_string_parameters("compiler_option",
|
||
"header_dir");
|
||
std::string str = "pwd";
|
||
const char *cmd = str.c_str();
|
||
CaptureStream capture(stdout);
|
||
capture.Begin();
|
||
system(cmd);
|
||
capture.End();
|
||
std::string wor_dir = capture.getData();
|
||
std::string break_dir = wor_dir.substr(0, wor_dir.find("build"));
|
||
std::string append_str = "catch/unit/rtc/headers";
|
||
std::string CO = retrived_CO + " " + break_dir + append_str;
|
||
hold_CO[i] = CO;
|
||
} else if (combi_vec_list[i] == "architecture") {
|
||
std::string retrived_CO = get_string_parameters("compiler_option",
|
||
"architecture");
|
||
hipDeviceProp_t prop;
|
||
HIP_CHECK(hipGetDeviceProperties(&prop, 0));
|
||
std::string actual_architecture = prop.gcnArchName;
|
||
std::string complete_CO = retrived_CO + actual_architecture;
|
||
hold_CO[i] = complete_CO;
|
||
} else if (check_positive_CO_present(combi_vec_list[i]) == 1) {
|
||
std::string positive_CO = get_string_parameters("compiler_option",
|
||
combi_vec_list[i]);
|
||
hold_CO[i] = positive_CO;
|
||
if (combi_vec_list[i] == "fast_math")
|
||
fast_math_present = 1;
|
||
} else if (check_negative_CO_present(combi_vec_list[i]) == 1) {
|
||
std::string split_block_name = combi_vec_list[i].substr(3,
|
||
combi_vec_list[i].length() - 3);
|
||
std::string negative_CO = get_string_parameters(
|
||
"reverse_compiler_option", split_block_name);
|
||
hold_CO[i] = negative_CO;
|
||
if (split_block_name == "fast_math")
|
||
fast_math_present = 0;
|
||
} else if ( combi_vec_list[i] == "conversion_error"
|
||
|| combi_vec_list[i] == "conversion_no_error"
|
||
|| combi_vec_list[i] == "conversion_no_warning"
|
||
|| combi_vec_list[i] == "conversion_warning") {
|
||
picojson::array compiler_option = get_array_parameters("compiler_option",
|
||
"error");
|
||
std::vector<std::string> CO_vec;
|
||
for (auto& indx : compiler_option) {
|
||
CO_vec.push_back(indx.get<std::string>());
|
||
}
|
||
if (combi_vec_list[i] == "conversion_error") {
|
||
hold_CO[i] = CO_vec[0];
|
||
} else if (combi_vec_list[i] == "conversion_no_error") {
|
||
hold_CO[i] = CO_vec[1];
|
||
} else if (combi_vec_list[i] == "conversion_warning") {
|
||
hold_CO[i] = CO_vec[2];
|
||
} else if (combi_vec_list[i] == "conversion_no_warning") {
|
||
hold_CO[i] = CO_vec[3];
|
||
}
|
||
} else if (combi_vec_list[i] == "off_ffp_contract"
|
||
|| combi_vec_list[i] == "on_ffp_contract"
|
||
|| combi_vec_list[i] == "fast_ffp_contract"
|
||
|| combi_vec_list[i] == "pragmas_ffp_contract") {
|
||
picojson::array compiler_option = get_array_parameters("compiler_option",
|
||
"ffp_contract");
|
||
std::vector<std::string> CO_vec;
|
||
for (auto& indx : compiler_option) {
|
||
CO_vec.push_back(indx.get<std::string>());
|
||
}
|
||
if (combi_vec_list[i] == "off_ffp_contract") {
|
||
hold_CO[i] = CO_vec[0];
|
||
} else if (combi_vec_list[i] == "on_ffp_contract") {
|
||
hold_CO[i] = CO_vec[1];
|
||
} else if (combi_vec_list[i] == "fast_ffp_contract") {
|
||
hold_CO[i] = CO_vec[2];
|
||
} else if (combi_vec_list[i] == "pragmas_ffp_contract") {
|
||
hold_CO[i] = CO_vec[3];
|
||
}
|
||
} else if (combi_vec_list[i] =="undef_macro") {
|
||
hold_CO[i] = undef_CO_vec[1].c_str();
|
||
undef_present = 1;
|
||
} else {
|
||
WARN("BLOCK NAME " << combi_vec_list[i] << " NOT PRESENT");
|
||
}
|
||
Combination_CO[i] = hold_CO[i].c_str();
|
||
}
|
||
int errors = 0;
|
||
for (int j = 0; j< combi_size; j++) {
|
||
std::string block_name = combi_vec_list[j].c_str();
|
||
if (!calling_resp_function(block_name, Combination_CO, combi_size,
|
||
max_thread_position, fast_math_present)) {
|
||
errors++;
|
||
}
|
||
Combination_CO[j] = hold_CO[j].c_str();
|
||
}
|
||
return errors;
|
||
}
|
||
|
||
int check_positive_CO_present(std::string find_string) {
|
||
static std::vector<std::string> positive_CO = {"macro", "warning", "rdc",
|
||
"denormals", "fp32_div_sqrt",
|
||
"Rpass_inline", "fast_math",
|
||
"slp_vectorize",
|
||
"amdgpu_ieee",
|
||
"unsafe_atomic",
|
||
"infinite_num", "NAN_num",
|
||
"slp_vectorize", "math_errno",
|
||
"associative_math",
|
||
"signed_zeros", "finite_math",
|
||
"trapping_math"};
|
||
if (std::find(positive_CO.begin(), positive_CO.end(),
|
||
find_string) != positive_CO.end())
|
||
return 1;
|
||
else
|
||
return 0;
|
||
}
|
||
|
||
int check_negative_CO_present(std::string find_string) {
|
||
static std::vector<std::string> negative_CO = {"no_fast_math",
|
||
"no_fp32_div_sqrt",
|
||
"no_denormals",
|
||
"no_slp_vectorize",
|
||
"no_amdgpu_ieee",
|
||
"no_unsafe_atomic",
|
||
"no_infinite_num",
|
||
"no_slp_vectorize",
|
||
"no_NAN_num",
|
||
"no_math_errno",
|
||
"no_associative_math",
|
||
"no_signed_zeros",
|
||
"no_finite_math",
|
||
"no_trapping_math"};
|
||
if (std::find(negative_CO.begin(), negative_CO.end(),
|
||
find_string) != negative_CO.end())
|
||
return 1;
|
||
else
|
||
return 0;
|
||
}
|
||
|
||
bool calling_resp_function(const std::string block_name,
|
||
const char** Combination_CO,
|
||
int Combination_CO_size, int max_thread_position,
|
||
int fast_math_present) {
|
||
if (block_name == "max_thread") {
|
||
return check_max_thread(Combination_CO, Combination_CO_size,
|
||
max_thread_position, fast_math_present);
|
||
} else if (block_name == "architecture") {
|
||
return check_architecture(Combination_CO, Combination_CO_size,
|
||
max_thread_position, fast_math_present);
|
||
} else if (block_name == "rdc") {
|
||
return check_rdc(Combination_CO, Combination_CO_size,
|
||
max_thread_position, fast_math_present);
|
||
} else if (block_name == "denormals") {
|
||
return check_denormals_enabled(Combination_CO, Combination_CO_size,
|
||
max_thread_position, fast_math_present);
|
||
} else if (block_name == "no_denormals") {
|
||
return check_denormals_disabled(Combination_CO, Combination_CO_size,
|
||
max_thread_position, fast_math_present);
|
||
} else if (block_name == "warning") {
|
||
return check_warning(Combination_CO, Combination_CO_size,
|
||
max_thread_position, fast_math_present);
|
||
} else if (block_name == "conversion_error") {
|
||
return check_conversionerror_enabled(Combination_CO, Combination_CO_size,
|
||
max_thread_position,
|
||
fast_math_present);
|
||
} else if (block_name == "conversion_no_error") {
|
||
return check_conversionerror_disabled(Combination_CO, Combination_CO_size,
|
||
max_thread_position,
|
||
fast_math_present);
|
||
} else if (block_name == "conversion_warning") {
|
||
return check_conversionwarning_enabled(Combination_CO, Combination_CO_size,
|
||
max_thread_position,
|
||
fast_math_present);
|
||
} else if (block_name == "conversion_no_warning") {
|
||
return check_conversionwarning_disabled(Combination_CO,
|
||
Combination_CO_size,
|
||
max_thread_position,
|
||
fast_math_present);
|
||
} else if (block_name == "Rpass_inline") {
|
||
return check_Rpass_inline(Combination_CO, Combination_CO_size,
|
||
max_thread_position, fast_math_present);
|
||
} else if (block_name == "macro") {
|
||
return check_macro(Combination_CO, Combination_CO_size,
|
||
max_thread_position, fast_math_present);
|
||
} else if (block_name == "undef_macro") {
|
||
return check_undef_macro(Combination_CO, Combination_CO_size,
|
||
max_thread_position, fast_math_present);
|
||
} else if (block_name == "header_dir") {
|
||
return check_header_dir(Combination_CO, Combination_CO_size,
|
||
max_thread_position, fast_math_present);
|
||
} else if (block_name == "no_fast_math") {
|
||
return check_fast_math_disabled(Combination_CO, Combination_CO_size,
|
||
max_thread_position, fast_math_present);
|
||
} else if (block_name == "fast_math") {
|
||
return check_fast_math_enabled(Combination_CO, Combination_CO_size,
|
||
max_thread_position, fast_math_present);
|
||
} else if (block_name == "off_ffp_contract") {
|
||
return check_ffp_contract_off(Combination_CO, Combination_CO_size,
|
||
max_thread_position, fast_math_present);
|
||
} else if (block_name == "on_ffp_contract") {
|
||
return check_ffp_contract_on(Combination_CO, Combination_CO_size,
|
||
max_thread_position, fast_math_present);
|
||
} else if (block_name == "fast_ffp_contract") {
|
||
return check_ffp_contract_fast(Combination_CO, Combination_CO_size,
|
||
max_thread_position, fast_math_present);
|
||
} else if (block_name == "no_unsafe_atomic") {
|
||
return check_unsafe_atomic_disabled(Combination_CO, Combination_CO_size,
|
||
max_thread_position,
|
||
fast_math_present);
|
||
} else if (block_name == "unsafe_atomic") {
|
||
return check_unsafe_atomic_enabled(Combination_CO, Combination_CO_size,
|
||
max_thread_position,
|
||
fast_math_present);
|
||
} else if (block_name == "no_slp_vectorize") {
|
||
return check_slp_vectorize_disabled(Combination_CO, Combination_CO_size,
|
||
max_thread_position,
|
||
fast_math_present);
|
||
} else if (block_name == "slp_vectorize") {
|
||
return check_slp_vectorize_enabled(Combination_CO, Combination_CO_size,
|
||
max_thread_position,
|
||
fast_math_present);
|
||
} else if (block_name == "infinite_num") {
|
||
return check_infinite_num_enabled(Combination_CO, Combination_CO_size,
|
||
max_thread_position,
|
||
fast_math_present);
|
||
} else if (block_name == "no_infinite_num") {
|
||
return check_infinite_num_disabled(Combination_CO, Combination_CO_size,
|
||
max_thread_position,
|
||
fast_math_present);
|
||
} else if (block_name == "NAN_num") {
|
||
return check_NAN_num_enabled(Combination_CO, Combination_CO_size,
|
||
max_thread_position, fast_math_present);
|
||
} else if (block_name == "no_NAN_num") {
|
||
return check_NAN_num_disabled(Combination_CO, Combination_CO_size,
|
||
max_thread_position, fast_math_present);
|
||
} else if (block_name == "finite_math") {
|
||
return check_finite_math_enabled(Combination_CO, Combination_CO_size,
|
||
max_thread_position, fast_math_present);
|
||
} else if (block_name == "no_finite_math") {
|
||
return check_finite_math_disabled(Combination_CO, Combination_CO_size,
|
||
max_thread_position, fast_math_present);
|
||
} else if (block_name == "associative_math") {
|
||
return check_associative_math_enabled(Combination_CO, Combination_CO_size,
|
||
max_thread_position,
|
||
fast_math_present);
|
||
} else if (block_name == "no_associative_math") {
|
||
return check_associative_math_disabled(Combination_CO, Combination_CO_size,
|
||
max_thread_position,
|
||
fast_math_present);
|
||
} else if (block_name == "signed_zeros") {
|
||
return check_signed_zeros_enabled(Combination_CO, Combination_CO_size,
|
||
max_thread_position,
|
||
fast_math_present);
|
||
} else if (block_name == "no_signed_zeros") {
|
||
return check_signed_zeros_disabled(Combination_CO, Combination_CO_size,
|
||
max_thread_position,
|
||
fast_math_present);
|
||
} else if (block_name == "trapping_math") {
|
||
return check_trapping_math_enabled(Combination_CO, Combination_CO_size,
|
||
max_thread_position,
|
||
fast_math_present);
|
||
} else if (block_name == "no_trapping_math") {
|
||
return check_trapping_math_disabled(Combination_CO, Combination_CO_size,
|
||
max_thread_position,
|
||
fast_math_present);
|
||
} else {
|
||
WARN("BLOCK NAME '" << block_name << "' not found");
|
||
return 0;
|
||
}
|
||
}
|
||
|
||
picojson::array getblock_fromconfig() {
|
||
std::string str = "pwd";
|
||
const char *cmd = str.c_str();
|
||
CaptureStream capture(stdout);
|
||
capture.Begin();
|
||
system(cmd);
|
||
capture.End();
|
||
std::string wor_dir = capture.getData();
|
||
std::string break_dir = wor_dir.substr(0, wor_dir.find("build"));
|
||
std::string append_str = "catch/unit/rtc/RtcConfig.json";
|
||
std::string config_path = break_dir + append_str;
|
||
std::string returnValue = "";
|
||
std::ifstream json_file(config_path.c_str());
|
||
if (!json_file.is_open()) {
|
||
WARN("Error loading config.jason");
|
||
exit(0);
|
||
}
|
||
std::string json_str((std::istreambuf_iterator<char>(json_file)),
|
||
std::istreambuf_iterator<char>());
|
||
picojson::value v;
|
||
std::string err = picojson::parse(v, json_str);
|
||
if (!err.empty()) {
|
||
WARN("empty config.jason");
|
||
exit(0);
|
||
}
|
||
picojson::array& blocks = v.get<picojson::array>();
|
||
return blocks;
|
||
}
|
||
|
||
std::string get_string_parameters(std::string para_name_to_retrieve,
|
||
std::string block_name) {
|
||
std::string returnValue = "";
|
||
picojson::array blocks = getblock_fromconfig();
|
||
for (picojson::value& block : blocks) {
|
||
picojson::object& block_obj = block.get<picojson::object>();
|
||
std::string blk_name = block_obj.at("block_name").get<std::string>();
|
||
if (blk_name == block_name) {
|
||
if (para_name_to_retrieve == "compiler_option") {
|
||
std::string compiler_opt =
|
||
block_obj.at("compiler_option").get<std::string>();
|
||
returnValue += compiler_opt;
|
||
} else if (para_name_to_retrieve == "Target_Vals") {
|
||
std::string Target_Vals =
|
||
block_obj.at("Target_Vals").get<std::string>();
|
||
returnValue += Target_Vals;
|
||
} else if (para_name_to_retrieve == "kernel_name") {
|
||
std::string ker_name = block_obj.at("kernel_name").get<std::string>();
|
||
returnValue += ker_name;
|
||
} else if (para_name_to_retrieve == "reverse_compiler_option") {
|
||
std::string reverse =
|
||
block_obj.at("reverse_compiler_option").get<std::string>();
|
||
returnValue += reverse;
|
||
} else if (para_name_to_retrieve == "ready_compiler_option") {
|
||
std::string ready_CO =
|
||
block_obj.at("ready_compiler_option").get<std::string>();
|
||
returnValue += ready_CO;
|
||
} else {
|
||
WARN("REQUESTED FIELD not present : " << para_name_to_retrieve);
|
||
}
|
||
} else {
|
||
continue;
|
||
}
|
||
}
|
||
return returnValue;
|
||
}
|
||
|
||
picojson::array get_array_parameters(std::string para_name_to_retrieve,
|
||
std::string block_name) {
|
||
std::string returnValue = "";
|
||
picojson::array blocks = getblock_fromconfig();
|
||
for (picojson::value& block : blocks) {
|
||
picojson::object& block_obj = block.get<picojson::object>();
|
||
std::string blk_name = block_obj.at("block_name").get<std::string>();
|
||
if (blk_name == block_name) {
|
||
if (para_name_to_retrieve == "Target_Vals") {
|
||
picojson::array& Target_Vals =
|
||
block_obj.at("Target_Vals").get<picojson::array>();
|
||
return Target_Vals;
|
||
} else if (para_name_to_retrieve == "single_CO") {
|
||
picojson::array& single_CO =
|
||
block_obj.at("single_CO").get<picojson::array>();
|
||
return single_CO;
|
||
} else if (para_name_to_retrieve == "Combi_CO") {
|
||
picojson::array& Combi_CO =
|
||
block_obj.at("Combi_CO").get<picojson::array>();
|
||
return Combi_CO;
|
||
} else if (para_name_to_retrieve == "Input_Vals") {
|
||
picojson::array& Input_Vals =
|
||
block_obj.at("Input_Vals").get<picojson::array>();
|
||
return Input_Vals;
|
||
} else if (para_name_to_retrieve == "Expected_Results") {
|
||
picojson::array& Expected =
|
||
block_obj.at("Expected_Results").get<picojson::array>();
|
||
return Expected;
|
||
} else if (para_name_to_retrieve == "Expected_Results_for_no") {
|
||
picojson::array& Expected_for_no =
|
||
block_obj.at("Expected_Results_for_no").get<picojson::array>();
|
||
return Expected_for_no;
|
||
} else if (para_name_to_retrieve == "compiler_option") {
|
||
picojson::array& compiler_option =
|
||
block_obj.at("compiler_option").get<picojson::array>();
|
||
return compiler_option;
|
||
} else if (para_name_to_retrieve == "reverse_compiler_option") {
|
||
picojson::array& reverse_compiler_option =
|
||
block_obj.at("reverse_compiler_option").get<picojson::array>();
|
||
return reverse_compiler_option;
|
||
} else if (para_name_to_retrieve == "Headers") {
|
||
picojson::array& Headers =
|
||
block_obj.at("Headers").get<picojson::array>();
|
||
return Headers;
|
||
} else if (para_name_to_retrieve == "Src_headers") {
|
||
picojson::array& Src_headers =
|
||
block_obj.at("Src_headers").get<picojson::array>();
|
||
return Src_headers;
|
||
} else if (para_name_to_retrieve == "depending_comp_optn") {
|
||
picojson::array& depending_comp_optn =
|
||
block_obj.at("depending_comp_optn").get<picojson::array>();
|
||
return depending_comp_optn;
|
||
} else {
|
||
WARN("REQUESTED FIELD not present : " << para_name_to_retrieve);
|
||
return picojson::array();
|
||
}
|
||
} else {
|
||
continue;
|
||
}
|
||
}
|
||
WARN("REQUESTED BLOCK " << block_name << " is not present ");
|
||
return picojson::array();
|
||
}
|