path: root/0316-Use-ai-ability-to-guide-optimization.patch

From 0b85ab4639e2d25314175962a6e41a841649b028 Mon Sep 17 00:00:00 2001
From: zhenyu zhao <zhaozhenyu17@huawei.com>
Date: Sun, 24 Nov 2024 17:29:13 +0800
Subject: [PATCH 3/5] Use ai ability to guide optimization.

---
 gcc/Makefile.in               |   8 +-
 gcc/ai4c-infer.cc             | 457 ++++++++++++++++++++++++++++++++++
 gcc/ai4c-infer.h              |  29 +++
 gcc/config/aarch64/aarch64.cc |  14 +-
 gcc/gcc.cc                    |  32 +++
 gcc/gcc.h                     |   1 +
 gcc/ipa-hardware-detection.cc |   6 +-
 gcc/onnx.fdata                |   1 +
 gcc/opts-global.cc            |  10 +
 9 files changed, 550 insertions(+), 8 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 bb6197a8e..6315462aa 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 000000000..99f7a6b45
--- /dev/null
+++ b/gcc/ai4c-infer.cc
@@ -0,0 +1,457 @@
+/* Lightweight AI Inference Framework.
+   Copyright (C) 2024-2024 Free Software Foundation, Inc.
+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
+<http://www.gnu.org/licenses/>.  */
+
+#include <unistd.h>
+#include <math.h>
+#include <cstring>
+#include <cstdio>
+#include <cstdlib>
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include "ai4c-infer.h"
+#include "config.h"
+#include "system.h"
+
+#define M_MODE_SIZE  6
+#define NATIVE_TUNE_SIZE 128
+#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[M_MODE_SIZE];
+static char native_tune[NATIVE_TUNE_SIZE];
+
+/* Intermediate computation results from the ONNX model.  */
+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.  */
+static int64_t initialized;
+static int64_t optimize_result;
+
+void
+prepare_native_tune_str (const char *info)
+{
+  gcc_assert (strlen (info) < NATIVE_TUNE_SIZE);
+  if (info)
+    strcpy (native_tune, info);
+  return;
+}
+
+void
+set_cache_info (int prefetches, int l1_cache_size,
+		int l1_cache_line_size, int l2_cache_size,
+		int prefetch_latency, int prefetch_distance_factor)
+{
+  gcc_assert (5 < M_MODE_SIZE);
+  argv_hw1[0] = prefetches;
+  argv_hw1[1] = l1_cache_size;
+  argv_hw1[2] = l1_cache_line_size;
+  argv_hw1[3] = l2_cache_size;
+  argv_hw1[4] = prefetch_latency;
+  argv_hw1[5] = prefetch_distance_factor;
+}
+
+/* Read float from onnx.fdata.  */
+
+float static
+read_float_from_file (FILE* file)
+{
+  char hex_float[8];
+  float result;
+
+  if (!file)
+    {
+      perror ("Can not open file.");
+      return result;
+    }
+    
+  if (fscanf (file, "%8s", hex_float) != 1)
+    {
+      perror ("Can not read hex from onnx.fdata.");
+      return result;
+    }
+
+  unsigned char bytes[4];
+  for (int i = 0; i < 4; i++)
+    {
+      sscanf(hex_float + 2 * i, "%2hhx", &bytes[i]);
+    }
+
+  memcpy(&result, bytes, sizeof(float));
+  return result;
+}
+
+/* To read model parameter information from onnx.fdata and store it into the
+   appropriate arrays.  */
+
+static void
+fill_node (const char *file_name)
+{
+  FILE *file = fopen (file_name, "rb");
+
+  if (!file)
+    {
+      perror ("Can not open file.");
+      return;
+    }
+
+   /* Read cats_strings from onnx.fdata.  */
+  char hex_string[2];
+  for (int i = 0; i < CATS_STRINGS_ROW; i++)
+    {
+      for (int j = 0; j < CATS_STRINGS_COL - 1; j++)
+	{
+	  if (fscanf(file, "%2s", hex_string) != 1)
+	    {
+	      perror ("Can not read cats_strings from onnx.fdata.");
+	      return;
+	    }
+	  cats_strings[i][j] = (unsigned char)strtol(hex_string, NULL, 16);
+	}
+	cats_strings[i][CATS_STRINGS_COL - 1] = '\0';
+    }
+  
+  /* Read offset from onnx.fdata.  */
+  for (int i = 0; i < OFFSET_ROW; i++)
+    {
+      float result = read_float_from_file (file);
+      offset[i] = result;
+    }
+  
+  /* Read scale from onnx.fdata.  */
+  for (int i = 0; i < SCALE_ROW; i++)
+    {
+      float result = read_float_from_file (file);
+      scale[i] = result;
+    }
+
+  /* Read coefficient from onnx.fdata.  */
+  for (int i = 0; i < COEFFICIENT_ROW; i++)
+    for (int j = 0; j < COEFFICIENT_COL; j++)
+      {
+	float result = read_float_from_file (file);
+	coefficient[i][j] = result;
+      }
+
+  /* Read coefficient1 from onnx.fdata.  */
+  for (int i = 0; i < COEFFICIENT1_ROW; i++)
+    for (int j = 0; j < COEFFICIENT1_COL; j++)
+      {
+	float result = read_float_from_file (file);
+	coefficient1[i][j] = result;
+      }
+
+  /* Read intercepts from onnx.fdata.  */
+  for (int i = 0; i < INTERCEPTS_ROW; i++)
+    {
+      float result = read_float_from_file (file);
+      intercepts[i] = result;
+    }
+
+  /* Read intercepts1 from onnx.fdata.  */
+  for (int i = 0; i < INTERCEPTS1_ROW; i++)
+    {
+      float result = read_float_from_file (file);
+      intercepts1[i] = result;
+    }
+
+  /* Read unity from onnx.fdata.  */
+  for (int i = 0; i < UNITY_ROW; i++)
+    {
+      float result = read_float_from_file (file);
+      unity[i] = result;
+    }
+
+  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 = i;
+    }
+  return out_idx;
+}
+
+static void
+preprocess (int argc, int64_t *argv, int64_t *in_modes)
+{
+  int default_int_val= 0;
+  for (int i = 0; i < argc && i < M_MODE_SIZE; i++)
+    {
+      if (i < argc)
+	{
+	  in_modes[i] = argv[i];
+	}
+      else
+	{
+	  in_modes[i] = default_int_val;
+	}
+    }
+}
+
+/* The process of model inference.  */
+static int
+graph_infer (int argc, const char *argv, int argc2, int64_t *argv2)
+{
+  const char *file_name = getenv ("GCC_AI4C_ONNX_FDATA");
+
+  if (access (file_name, F_OK) == 0)
+    {
+      fill_node (file_name);
+    }
+  else
+    {
+      return 0;
+    }
+
+  int64_t in_modes[M_MODE_SIZE];
+
+  preprocess (argc2, argv2, in_modes);
+  
+  /* concat_result and encoder_out are intermediate computation results from
+     the ONNX model. concat_result is a 1 × 18 matrix, and encoder_out is a
+     1 × 12 matrix.  */
+
+  const int concat_out_size = 18;
+  float concat_result[concat_out_size];
+  const int encoder_out_size = 12;
+  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, 0);
+
+  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);
+
+  /* This requires performing matrix multiplication between a 1 × 18 matrix
+     and an 18 × 100 matrix  */
+
+  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);
+
+  /* This requires performing matrix multiplication between a 1 × 100 matrix
+     and an 100 × 1 matrix  */
+
+  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.");
+	return;
+      }
+
+    fgets (output, output_size, pipe);
+    pclose (pipe);
+}
+
+int
+get_optimize_decision_from_ai4c ()
+{
+  if (initialized== 1)
+    {
+      return optimize_result;
+    }
+  if (native_tune && (strchr (native_tune, '+') != NULL))
+    {
+      char hash[65];
+      char input[64];
+      const char prefix = '=';
+      const char *start = strchr (native_tune, prefix);
+      if (start)
+	{
+	  start += 1;
+	  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));
+      optimize_result = graph_infer (1, hash, M_MODE_SIZE, argv_hw1);
+      initialized = 1;
+      if (optimize_result == 1)
+	setenv ("AI_GUIDED", "1", 1);
+    }
+  return optimize_result;
+}
diff --git a/gcc/ai4c-infer.h b/gcc/ai4c-infer.h
new file mode 100644
index 000000000..7fb75900b
--- /dev/null
+++ b/gcc/ai4c-infer.h
@@ -0,0 +1,29 @@
+/* Lightweight AI Inference Framework.
+
+   Copyright (C) 2024-2024 Free Software Foundation, Inc.
+
+   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
+   <http://www.gnu.org/licenses/>.  */
+
+#ifndef AI4C_INFER_H
+#define AI4C_INFER_H
+
+extern int get_optimize_decision_from_ai4c ();
+extern void set_cache_info (int prefetches, int l1_cache_size, 
+			    int l1_cache_line_size, int l2_cache_size,
+			    int prefetch_latency, int prefetch_distance_factor);
+extern void prepare_native_tune_str (const char *info);
+#endif /* AI4C_INFER_H */
\ No newline at end of file
diff --git a/gcc/config/aarch64/aarch64.cc b/gcc/config/aarch64/aarch64.cc
index 08a43541e..1d479f270 100644
--- a/gcc/config/aarch64/aarch64.cc
+++ b/gcc/config/aarch64/aarch64.cc
@@ -18764,12 +18764,14 @@ override_C_optimize_options (struct gcc_options *opts)
   opts->x_flag_ipa_struct_reorg = 6;
   opts->x_struct_layout_optimize_level = 6;
   opts->x_flag_gnu89_inline = 1;
-  opts->x_flag_ccmp2 = 1;
-  opts->x_flag_array_widen_compare = 1;
   opts->x_flag_convert_minmax = 1;
   opts->x_flag_tree_slp_transpose_vectorize = 1;
   opts->x_param_max_inline_insns_auto = 64;
   opts->x_param_inline_unit_growth = 96;
+  opts->x_param_pointer_compression_size = 16;
+  opts->x_semi_relayout_level = 14;
+  opts->x_flag_ipa_prefetch = 1;
+  opts->x_flag_ipa_ic = 1;
 }
 
 /* Check whether in CPP language or LTO with only CPP language.  */
@@ -18826,6 +18828,8 @@ override_optimize_options_1 (struct gcc_options *opts)
   opts->x_param_ifcvt_allow_register_renaming = 2;
   opts->x_param_max_rtl_if_conversion_unpredictable_cost = 48;
   opts->x_param_max_rtl_if_conversion_predictable_cost = 48;
+  opts->x_flag_ccmp2 = 1;
+  opts->x_flag_array_widen_compare = 1;
 }
 
 static void
@@ -18848,6 +18852,8 @@ override_Fortran_optimize_options (struct gcc_options *opts)
   opts->x_flag_reorder_blocks = 1;
   opts->x_flag_crypto_accel_aes = 1;
   opts->x_param_flexible_seg_len = 1;
+  opts->x_flag_alias_analysis_expand_ssa = 1;
+  opts->x_flag_chrec_mul_fold_strict_overflow = 1;
 }
 
 /* Reset the optimize option.
@@ -18857,7 +18863,9 @@ static void
 reset_machine_option (struct gcc_options *opts)
 {
   if (!(opts->x_optimize_maximum)
-      || strstr (opts->x_aarch64_tune_string, "hip09") == NULL)
+      || opts->x_aarch64_cpu_string == NULL
+      || (strstr (opts->x_aarch64_cpu_string, "tsv110") == NULL
+      && strstr (opts->x_aarch64_cpu_string, "hip09") == NULL))
     {
       return;
     }
diff --git a/gcc/gcc.cc b/gcc/gcc.cc
index 32e45adc2..4592a4ec8 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 ("GCC_AI4C_TUNE_INFO", tune_native, 1);
+
   /* Mark %<S switches processed by do_self_spec to be ignored permanently.
      do_self_specs adds the replacements to switches array, so it shouldn't
      be processed afterwards.  */
@@ -8121,6 +8124,7 @@ driver::main (int argc, char **argv)
   putenv_COLLECT_AS_OPTIONS (assembler_options);
   putenv_COLLECT_GCC (argv[0]);
   maybe_putenv_COLLECT_LTO_WRAPPER ();
+  putenv_ONNX_FDATA ();
   maybe_putenv_OFFLOAD_TARGETS ();
   handle_unrecognized_options ();
 
@@ -8551,6 +8555,34 @@ driver::putenv_COLLECT_GCC (const char *argv0) const
   xputenv (XOBFINISH (&collect_obstack, char *));
 }
 
+/* Set up to remember the pathname of the onnx.fdata.  */
+
+void
+driver::putenv_ONNX_FDATA () const
+{
+  char *lto_wrapper_file;
+  lto_wrapper_file = find_a_program ("lto-wrapper");
+
+  if (lto_wrapper_file)
+    {
+      lto_wrapper_file = convert_white_space (lto_wrapper_file);
+      char native_file[512];
+      const char *onnx_fdata = "onnx.fdata";
+      strncpy (native_file, lto_wrapper_file, 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);
+      obstack_init (&collect_obstack);
+      obstack_grow (&collect_obstack, "GCC_AI4C_ONNX_FDATA=",
+		    sizeof ("GCC_AI4C_ONNX_FDATA=") - 1);
+      obstack_grow (&collect_obstack,  native_file,
+		    strlen ( native_file) + 1);
+      xputenv (XOBFINISH (&collect_obstack, char *));
+    }
+
+}
+
 /* Set up to remember the pathname of the lto wrapper. */
 
 void
diff --git a/gcc/gcc.h b/gcc/gcc.h
index 63231ddb3..ff3ae8bed 100644
--- a/gcc/gcc.h
+++ b/gcc/gcc.h
@@ -44,6 +44,7 @@ class driver
   void set_up_specs () const;
   void putenv_COLLECT_GCC (const char *argv0) const;
   void maybe_putenv_COLLECT_LTO_WRAPPER () const;
+  void putenv_ONNX_FDATA () const;
   void maybe_putenv_OFFLOAD_TARGETS () const;
   void handle_unrecognized_options ();
   int maybe_print_and_exit () const;
diff --git a/gcc/ipa-hardware-detection.cc b/gcc/ipa-hardware-detection.cc
index 8085a8c65..75b74aa03 100644
--- a/gcc/ipa-hardware-detection.cc
+++ b/gcc/ipa-hardware-detection.cc
@@ -39,6 +39,7 @@ along with GCC; see the file COPYING3.  If not see
 #include "cfghooks.h"
 #include "gimple-fold.h"
 #include "gimplify-me.h"
+#include "ai4c-infer.h"
 
 namespace {
 
@@ -191,10 +192,11 @@ bool
 pass_ipa_hardware_detection::gate (function *)
 {
   const char *ai_infer_level = getenv ("AI_INFER_LEVEL");
-  return (ai_infer_level
+  const char *ai_guided = getenv ("AI_GUIDED");
+  return (ai_guided || (ai_infer_level
 	  && optimize_maximum > 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 000000000..234b1a045
--- /dev/null
+++ b/gcc/onnx.fdata
@@ -0,0 +1 @@
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
\ No newline at end of file
diff --git a/gcc/opts-global.cc b/gcc/opts-global.cc
index a18c76940..e684bc5e3 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 (global_options.x_param_simultaneous_prefetches,
+		  global_options.x_param_l1_cache_size,
+		  global_options.x_param_l1_cache_line_size,
+		  global_options.x_param_l2_cache_size,
+		  global_options.x_param_prefetch_latency,
+		  global_options.x_param_ipa_prefetch_distance_factor);
+  const char *tune_native = getenv ("GCC_AI4C_TUNE_INFO");
+  prepare_native_tune_str (tune_native);
+
   struct cl_option_handlers handlers;
 
   unsigned int lang_mask;
-- 
2.33.0