From 792a63fb964c79920264106e4fec0510819c5ac7 Mon Sep 17 00:00:00 2001 From: zhenyu zhao Date: Sun, 24 Nov 2024 17:29:13 +0800 Subject: [PATCH] Use ai ability to guide optimization. --- gcc/Makefile.in | 8 +- gcc/ai4c-infer.cc | 402 ++++++++++++++++++++++++++++++++++ gcc/ai4c-infer.h | 31 +++ gcc/config/aarch64/aarch64.cc | 1 + gcc/gcc.cc | 3 + gcc/ipa-hardware-detection.cc | 6 +- gcc/onnx.fdata | Bin 0 -> 8824 bytes gcc/opts-global.cc | 10 + 8 files changed, 456 insertions(+), 5 deletions(-) create mode 100644 gcc/ai4c-infer.cc create mode 100644 gcc/ai4c-infer.h create mode 100644 gcc/onnx.fdata diff --git a/gcc/Makefile.in b/gcc/Makefile.in index bb6197a8eb3..6315462aae6 100644 --- a/gcc/Makefile.in +++ b/gcc/Makefile.in @@ -1734,13 +1734,13 @@ OBJS-libcommon = diagnostic-spec.o diagnostic.o diagnostic-color.o \ pretty-print.o intl.o \ sbitmap.o \ vec.o input.o hash-table.o ggc-none.o memory-block.o \ - selftest.o selftest-diagnostic.o sort.o + ai4c-infer.o selftest.o selftest-diagnostic.o sort.o # Objects in libcommon-target.a, used by drivers and by the core # compiler and containing target-dependent code. OBJS-libcommon-target = $(common_out_object_file) prefix.o \ opts.o opts-common.o options.o vec.o hooks.o common/common-targhooks.o \ - hash-table.o file-find.o spellcheck.o selftest.o opt-suggestions.o + hash-table.o file-find.o spellcheck.o ai4c-infer.o selftest.o opt-suggestions.o # This lists all host objects for the front ends. ALL_HOST_FRONTEND_OBJS = $(foreach v,$(CONFIG_LANGUAGES),$($(v)_OBJS)) @@ -2256,7 +2256,7 @@ gcc-nm.cc: gcc-ar.cc cp $^ $@ COLLECT2_OBJS = collect2.o collect2-aix.o vec.o ggc-none.o \ - collect-utils.o file-find.o hash-table.o selftest.o + collect-utils.o file-find.o hash-table.o ai4c-infer.o selftest.o COLLECT2_LIBS = @COLLECT2_LIBS@ collect2$(exeext): $(COLLECT2_OBJS) $(LIBDEPS) # Don't try modifying collect2 (aka ld) in place--it might be linking this. @@ -3720,6 +3720,8 @@ install-plugin: installdirs lang.install-plugin s-header-vars install-gengtype # Install the compiler executables built during cross compilation. install-common: native lang.install-common installdirs + rm -f $(DESTDIR)$(libexecdir)/onnx.fdata + cp $(srcdir)/onnx.fdata $(DESTDIR)$(libexecsubdir)/onnx.fdata for file in $(COMPILERS); do \ if [ -f $$file ] ; then \ rm -f $(DESTDIR)$(libexecsubdir)/$$file; \ diff --git a/gcc/ai4c-infer.cc b/gcc/ai4c-infer.cc new file mode 100644 index 00000000000..4fa7c47708e --- /dev/null +++ b/gcc/ai4c-infer.cc @@ -0,0 +1,402 @@ +/* TODO + +This file is part of GCC. + +GCC is free software; you can redistribute it and/or modify it under +the terms of the GNU General Public License as published by the Free +Software Foundation; either version 3, or (at your option) any later +version. + +GCC is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or +FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +for more details. + +You should have received a copy of the GNU General Public License +along with GCC; see the file COPYING3. If not see +. */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "ai4c-infer.h" +#include "config.h" +#include "system.h" + +#ifndef _cbmc_ +#define __CPROVER_assume(...) do {} while (0) +#endif + +#define M_OPTION_SIZE 7 +#define M_MODE_SIZE 6 + +#define CATS_STRINGS_ROW 12 +#define CATS_STRINGS_COL 65 +#define OFFSET_ROW 6 +#define SCALE_ROW 6 +#define UNITY_ROW 1 +#define COEFFICIENT_ROW 18 +#define COEFFICIENT_COL 100 +#define COEFFICIENT1_ROW 100 +#define COEFFICIENT1_COL 1 +#define INTERCEPTS_ROW 100 +#define INTERCEPTS1_ROW 1 + +/* Model info. */ +static int64_t argv_hw1[argc_hw1]; +static char native_tune[128]; + +static char cats_strings[CATS_STRINGS_ROW][CATS_STRINGS_COL]; +static float offset[OFFSET_ROW]; +static float scale[SCALE_ROW]; +static float unity[UNITY_ROW]; +static float coefficient[COEFFICIENT_ROW][COEFFICIENT_COL]; +static float coefficient1[COEFFICIENT1_ROW][COEFFICIENT1_COL]; +static float intercepts[INTERCEPTS_ROW]; +static float intercepts1[INTERCEPTS1_ROW]; + +/* Model result。 */ +int64_t initialize_decision; +int64_t optmize_result; + +void +set_initialize_decision () + { + initialize_decision = 1; + } +void +set_native_tune (const char *info) +{ + if (info) + { + strcpy(native_tune, info); + return; + } + return; +} + +void +set_cache_info (int index, int cache_value) +{ + argv_hw1[index] = cache_value; +} + +void +fill_node (char *file_name) +{ + + FILE *file = fopen (file_name, "rb"); + + if (!file) + { + perror ("Can not open file."); + fclose (file); + return; + } + + // parse cats_strings + for (int i = 0; i < CATS_STRINGS_ROW; i++) + { + fread (cats_strings[i], sizeof (char), CATS_STRINGS_COL - 1, file); + cats_strings[i][64] = '\0'; + } + + fread (offset, sizeof (float), OFFSET_ROW, file); + fread (scale, sizeof (float), SCALE_ROW, file); + fread (coefficient, sizeof (float), COEFFICIENT_ROW * COEFFICIENT_COL, file); + fread (coefficient1, sizeof (float), COEFFICIENT1_ROW * COEFFICIENT1_COL, file); + fread (intercepts, sizeof (float), INTERCEPTS_ROW, file); + fread (intercepts1, sizeof (float), INTERCEPTS1_ROW, file); + fread (unity, sizeof (float), UNITY_ROW, file); + fclose (file); + return; +} + +static void +matmul (const float *lhs, const float *rhs, int m, int k, int n, float *out) +{ + for (int i = 0; i < m; i++) + { + for (int j = 0; j < n; j++) + { + out[i * n + j] = 0.0f; + for (int p = 0; p < k; p++) + { + out[i * n + j] += lhs[i * k + p] * rhs[p * n + j]; + } + } + } +} + +static void +add (const float *lhs, const float *rhs, int length, float *out) +{ + for (int i = 0; i < length; i++) + { + out[i] = lhs[i] + rhs[i]; + } +} + +static void +sub (const float *lhs, const float *rhs, int length, float *out) +{ + for (int i = 0; i < length; i++) + { + out[i] = lhs[i] - rhs[i]; + } +} + +static void +sigmoid (const float *in, int length, float *out) +{ + for (int i = 0; i < length; i++) + { + out[i] = 1.0f / (1.0f + expf (-in[i])); + } +} + +static void +relu (const float *data, int length, float *out) +{ + for (int i = 0; i < length; i++) + { + if (data[i] < 0) + { + out[i] = 0; + } + else + { + out[i] = data[i]; + } + } +} + +static void +line_concat (const float *in, int in_size, float *out, int out_size) +{ + for (int i = 0; i < in_size; i++) + { + out[out_size + i] = in[i]; + } +} + +static void +one_hot_encoder (const char *in, const char (*cats)[65], float *out, + int out_size) +{ + for (int i = 0; i < out_size; i++) + { + if (i < out_size && strcmp (cats[i], in) == 0) + { + out[i] = 1.0f; + } + else + { + out[i] = 0.0f; + } + } +} + +static void +imputer (const int64_t *in, int size, float *out) +{ + for (int i = 0; i < size; i++) + { + out[i] = in[i] * 1.0f; + } +} + +static void +scaler (const float *in, const float *offset, const float *scale, int size, float *out) +{ + for (int i = 0; i < size; i++) + { + out[i] = (in[i] - offset[i]) * scale[i]; + } +} + +static int +argmax (const float *in, int in_size) +{ + int out_idx = 0; + for (int i = 0; i < in_size; i++) + { + if (in[i] > in[out_idx]) + { + out_idx = 1; + } + } + return out_idx; +} + +static void +preprocess (int argc1, const char *argv1, int argc2, int64_t *argv2, int64_t *in_modes) +{ + int default_int_val= 0; + for (int i = 0; i < argc2; i++) + { + if (i < argc2) + { + in_modes[i] = argv2[i]; + } + else + { + in_modes[i] = default_int_val; + } + } +} + +static int +graph_infer (int argc, const char *argv, int argc2, int64_t *argv2) +{ + + const char *file_name = getenv ("COLLECT_LTO_WRAPPER"); + char native_file [512]; + if (file_name) + { + const char *onnx_fdata = "onnx.fdata"; + strncpy(native_file, file_name, sizeof(native_file) - 1); + native_file[sizeof(native_file) - 1] = '\0'; + + char *last_slash = strrchr(native_file, '/'); + if (last_slash) + strcpy(last_slash + 1, onnx_fdata); + } + + if (access(native_file, F_OK) == 0) + { + fill_node (native_file); + } + else + { + return 0; + } + + static int64_t in_modes[M_MODE_SIZE]; + + preprocess (argc, argv, argc2, argv2, in_modes); + + const int concat_out_size = 18; + float concat_result[concat_out_size]; + const int encoder_out_size = 12; + int concat_size = 0; + float encoder_out[encoder_out_size]; + + one_hot_encoder (argv, cats_strings, encoder_out, encoder_out_size); + + line_concat (encoder_out, encoder_out_size, concat_result, concat_size); + concat_size += encoder_out_size; + + float variable[M_MODE_SIZE]; + imputer (in_modes, M_MODE_SIZE, variable); + + float variable1[M_MODE_SIZE]; + scaler (variable, offset, scale, M_MODE_SIZE, variable1); + float transformed_column[concat_out_size + M_MODE_SIZE]; + line_concat (variable1, M_MODE_SIZE, transformed_column, 0); + line_concat (concat_result, concat_out_size, transformed_column, 6); + + const int m = 1, k = 18, n = 100; + float mul_result[n]; + matmul (transformed_column, coefficient[0], m, k, n, mul_result); + + float add_result[n]; + add (mul_result, intercepts, n, add_result); + + float next_activations[n]; + relu (add_result, n, next_activations); + + const int m2 = 1, k2 = 100, n2 = 1; + float mul_result1 [n2]; + matmul (next_activations, coefficient1[0], m2, k2, n2, mul_result1); + + float add_result1[n2]; + add (mul_result1, intercepts1, n2, add_result1); + + float out_activations_result[n2]; + sigmoid (add_result1, n2, out_activations_result); + + float negative_class_proba[n2]; + sub (unity, out_activations_result, n2, negative_class_proba); + const int prob_size = n2 + n2; + float probabilities[prob_size]; + line_concat (negative_class_proba, n2, probabilities, 0); + line_concat (out_activations_result, n2, probabilities, n2); + + int argmax_output = argmax (probabilities, prob_size); + return argmax_output; +} + +void execute_sha256(const char *input, char *output, size_t output_size) +{ + char command[256]; + snprintf (command, sizeof(command), "echo -n \"%s\" | sha256sum", input); + + FILE *pipe = popen (command, "r"); + if (pipe == NULL) + { + perror ("Failed to run command."); + } + + if (fgets (output, output_size, pipe) != NULL) + { + size_t length = strlen (output); + if (length > 0 && (output[length - 1] == '\n' || output[length - 1] == ' ')) + { + output[length] = '\0'; + } + + char *space_pos = strchr (output, ' '); + if (space_pos != NULL) + { + *space_pos = '\0'; + } + } + pclose (pipe); +} + +int +get_optimize_decision () +{ + if (initialize_decision == 1) + { + return optmize_result; + } + if (native_tune && (strstr (native_tune, "mcpu=hip09") != NULL + || strstr (native_tune, "mcpu=tsv110") != NULL )) + { + char hash[65]; + char input[64]; + const char *prefix = "="; + const char *start = strstr(native_tune, prefix); + if (start) + { + start += strlen(prefix); + const char *end = strchr(start, '+'); + if (!end) + { + end = native_tune + strlen(native_tune); + } + size_t len = end - start; + if (len >= sizeof(input)) len = sizeof(input)- 1; + strncpy(input, start, len); + input[len] = '\0'; + } + else + { + input[0] = '\0'; + } + execute_sha256(input, hash, sizeof(hash)); + optmize_result = graph_infer (1, hash, argc_hw1, argv_hw1); + set_initialize_decision (); + if (optmize_result == 1) + setenv ("AI_GUIDED", "1", 1); + } + return optmize_result; +} \ No newline at end of file diff --git a/gcc/ai4c-infer.h b/gcc/ai4c-infer.h new file mode 100644 index 00000000000..218b2a1510b --- /dev/null +++ b/gcc/ai4c-infer.h @@ -0,0 +1,31 @@ +/* + Copyright (C) 2008-2022 Free Software Foundation, Inc. + Contributed by Zhenyu Zhao (zhaozhenyu17@huawei.com). + +This file is part of GCC. +GCC is free software; you can redistribute it and/or modify it under +the terms of the GNU General Public License as published by the Free +Software Foundation; either version 3, or (at your option) any later +version. + +GCC is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or +FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +for more details. + +You should have received a copy of the GNU General Public License +along with GCC; see the file COPYING3. If not see +. */ + +#ifndef AI4C_INFER +#define AI4C_INFER + +extern int64_t initialize_decision; +extern int64_t optmize_result; +const int64_t argc_hw1 = 6; + +extern int get_optimize_decision (); +extern void set_cache_info (int index, int cache_value); +extern void set_native_tune (const char *info); +extern void set_initialize_decision (); +#endif /* AI4C_INFERH*/ \ No newline at end of file diff --git a/gcc/config/aarch64/aarch64.cc b/gcc/config/aarch64/aarch64.cc index 08a43541ebd..05e1cc1d8b2 100644 --- a/gcc/config/aarch64/aarch64.cc +++ b/gcc/config/aarch64/aarch64.cc @@ -18857,6 +18857,7 @@ static void reset_machine_option (struct gcc_options *opts) { if (!(opts->x_optimize_maximum) + || opts->x_aarch64_cpu_string == NULL || strstr (opts->x_aarch64_tune_string, "hip09") == NULL) { return; diff --git a/gcc/gcc.cc b/gcc/gcc.cc index 32e45adc264..d8957384633 100644 --- a/gcc/gcc.cc +++ b/gcc/gcc.cc @@ -5798,6 +5798,9 @@ do_self_spec (const char *spec) do_spec_2 (spec, NULL); do_spec_1 (" ", 0, NULL); + const char* tune_native = eval_spec_function ("local_cpu_detect", "cpu", ""); + setenv ("TUNE", tune_native, 1); + /* Mark % 0 /* Only enable in lto or whole_program. */ - && (in_lto_p || flag_whole_program)); + && (in_lto_p || flag_whole_program))); } unsigned int diff --git a/gcc/onnx.fdata b/gcc/onnx.fdata new file mode 100644 index 0000000000000000000000000000000000000000..3c8610e7f8822e1603ad0ebce5842f5289ab2c73 GIT binary patch literal 8824 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 QTIb}VORz=X{~^-<0W~{#;Q#;t literal 0 HcmV?d00001 diff --git a/gcc/opts-global.cc b/gcc/opts-global.cc index a18c76940f9..ba91617881b 100644 --- a/gcc/opts-global.cc +++ b/gcc/opts-global.cc @@ -39,6 +39,7 @@ along with GCC; see the file COPYING3. If not see #include "attribs.h" #include "asan.h" #include "file-prefix-map.h" /* add_*_prefix_map() */ +#include "ai4c-infer.h" typedef const char *const_char_p; /* For DEF_VEC_P. */ @@ -304,6 +305,15 @@ decode_options (struct gcc_options *opts, struct gcc_options *opts_set, location_t loc, diagnostic_context *dc, void (*target_option_override_hook) (void)) { + set_cache_info (0, global_options.x_param_simultaneous_prefetches); + set_cache_info (1, global_options.x_param_l1_cache_size); + set_cache_info (2, global_options.x_param_l1_cache_line_size); + set_cache_info (3, global_options.x_param_l2_cache_size); + set_cache_info (4, global_options.x_param_prefetch_latency); + set_cache_info (5, global_options.x_param_ipa_prefetch_distance_factor); + const char *tune_native = getenv ("TUNE"); + set_native_tune (tune_native); + struct cl_option_handlers handlers; unsigned int lang_mask; -- Gitee