#!/system/bin/sh

BUSYBOX="/data/data/com.paget96.lsandroid/files/binary/busybox"
LOG="/data/data/com.paget96.lsandroid/files/log/mainLog"
SETUP_DIR="/data/data/com.paget96.lsandroid/files/setup"

# cpu_detect output files
CPU_DETECT_DATA_DIR="$SETUP_DIR/cpu_detect"
CPU_CORE_COUNT="$CPU_DETECT_DATA_DIR/cpu_core_count"
REAL_CPU_CORE_COUNT="$CPU_DETECT_DATA_DIR/real_cpu_core_count"
MIN_MAX_FREQ="$CPU_DETECT_DATA_DIR/min_max_freq"
MIN_FREQ_LIST="$CPU_DETECT_DATA_DIR/min_freq_list"
MAX_FREQ_LIST="$CPU_DETECT_DATA_DIR/max_freq_list"
LOGICAL_CORE="$CPU_DETECT_DATA_DIR/logical_core"
AFFECTED_CPU="$CPU_DETECT_DATA_DIR/affected_cpu"
UNIQUE_FREQ="$CPU_DETECT_DATA_DIR/unique_freq"
CORE_GETTER="$CPU_DETECT_DATA_DIR/core_getter"
PRIME_CORES_COUNT="$CPU_DETECT_DATA_DIR/prime_cores_count"
BIG_CORES_COUNT="$CPU_DETECT_DATA_DIR/big_cores_count"
LITTLE_CORES_COUNT="$CPU_DETECT_DATA_DIR/little_cores_count"
divider="==============================================="

sendToLog() {
  timeZone=$(getprop persist.sys.timezone)
  printDate=$(TZ="$timeZone" $BUSYBOX date +"%H:%M:%S:%3N %d-%m-%Y")

  echo "[$printDate] $1" >>$LOG
}

write() {
  #chmod 0644 "$1"
  echo "$2" >"$1"
}

#######
# Method returns the numbers of CPU cores
#######
getCPUcoreCount() {
  rm -rf $CPU_CORE_COUNT
  rm -rf $REAL_CPU_CORE_COUNT

  real_cpu_cores=$($BUSYBOX ls /sys/devices/system/cpu | $BUSYBOX grep -c ^cpu[0-9])
  cpu_cores=$((real_cpu_cores - 1))

  echo "$cpu_cores" >$CPU_CORE_COUNT
  echo "$real_cpu_cores" >$REAL_CPU_CORE_COUNT

  sleep 0.5

  unset real_cpu_cores
  unset cpu_cores
}

#######
# Method returns min and max frequencies as list
#######
getMinAndMaxFreq() {
  rm -rf $MIN_MAX_FREQ

  core_count=$($BUSYBOX cat $CPU_CORE_COUNT)
  core=0
  while [ $core -le "$core_count" ]; do

    scalingAvailableFrequencies=/sys/devices/system/cpu/cpu$core/cpufreq/scaling_available_frequencies

    if [ -e $scalingAvailableFrequencies ]; then
      minFreq=$($BUSYBOX cat $scalingAvailableFrequencies | $BUSYBOX tr '\n' ' ' | $BUSYBOX awk '{print $1}')
      maxFreq=$($BUSYBOX cat $scalingAvailableFrequencies | $BUSYBOX tr '\n' ' ' | $BUSYBOX awk '{print $NF}')

      if [ "$minFreq" -lt "$maxFreq" ]; then
        echo "$minFreq " >>$MIN_MAX_FREQ
        echo "$maxFreq " >>$MIN_MAX_FREQ
      elif [ "$minFreq" -gt "$maxFreq" ]; then
        echo "$maxFreq " >>$MIN_MAX_FREQ
        echo "$minFreq " >>$MIN_MAX_FREQ
      fi
    fi

    core=$((core + 1))
  done

  unset core
  unset scalingAvailableFrequencies
  unset minFreq
  unset maxFreq

  # This is for devices with mp-cpufreq dir
  if [ ! -e /sys/devices/system/cpu/cpu0/cpufreq/scaling_available_frequencies ]; then
    rm -rf $MIN_MAX_FREQ

    cluster0FreqTable=/sys/devices/system/cpu/cpufreq/mp-cpufreq/cluster0_freq_table
    cluster1FreqTable=/sys/devices/system/cpu/cpufreq/mp-cpufreq/cluster1_freq_table
    cluster2FreqTable=/sys/devices/system/cpu/cpufreq/mp-cpufreq/cluster2_freq_table
    kfcFreqTable=/sys/devices/system/cpu/cpufreq/mp-cpufreq/kfc_freq_table
    cpuFreqTable=/sys/devices/system/cpu/cpufreq/mp-cpufreq/cpu_freq_table

    if [ -e $cluster0FreqTable ]; then
      minFreq=$($BUSYBOX cat $cluster0FreqTable | $BUSYBOX tr '\n' ' ' | $BUSYBOX awk '{print $1}')
      maxFreq=$($BUSYBOX cat $cluster0FreqTable | $BUSYBOX tr '\n' ' ' | $BUSYBOX awk '{print $NF}')

      if [ "$minFreq" -lt "$maxFreq" ]; then
        echo "$minFreq " >>$MIN_MAX_FREQ
        echo "$maxFreq " >>$MIN_MAX_FREQ
      elif [ "$minFreq" -gt "$maxFreq" ]; then
        echo "$maxFreq " >>$MIN_MAX_FREQ
        echo "$minFreq " >>$MIN_MAX_FREQ
      fi
    fi
    unset minFreq
    unset maxFreq

    if [ -e $cluster1FreqTable ]; then
      minFreq=$($BUSYBOX cat $cluster1FreqTable | $BUSYBOX tr '\n' ' ' | $BUSYBOX awk '{print $1}')
      maxFreq=$($BUSYBOX cat $cluster1FreqTable | $BUSYBOX tr '\n' ' ' | $BUSYBOX awk '{print $NF}')

      if [ "$minFreq" -lt "$maxFreq" ]; then
        echo "$minFreq " >>$MIN_MAX_FREQ
        echo "$maxFreq " >>$MIN_MAX_FREQ
      elif [ "$minFreq" -gt "$maxFreq" ]; then
        echo "$maxFreq " >>$MIN_MAX_FREQ
        echo "$minFreq " >>$MIN_MAX_FREQ
      fi
    fi
    unset minFreq
    unset maxFreq

    if [ -e $cluster2FreqTable ]; then
      minFreq=$($BUSYBOX cat $cluster2FreqTable | $BUSYBOX tr '\n' ' ' | $BUSYBOX awk '{print $1}')
      maxFreq=$($BUSYBOX cat $cluster2FreqTable | $BUSYBOX tr '\n' ' ' | $BUSYBOX awk '{print $NF}')

      if [ "$minFreq" -lt "$maxFreq" ]; then
        echo "$minFreq " >>$MIN_MAX_FREQ
        echo "$maxFreq " >>$MIN_MAX_FREQ
      elif [ "$minFreq" -gt "$maxFreq" ]; then
        echo "$maxFreq " >>$MIN_MAX_FREQ
        echo "$minFreq " >>$MIN_MAX_FREQ
      fi
    fi
    unset minFreq
    unset maxFreq

    if [ -e $kfcFreqTable ]; then
      minFreq=$($BUSYBOX cat $kfcFreqTable | $BUSYBOX tr '\n' ' ' | $BUSYBOX awk '{print $1}')
      maxFreq=$($BUSYBOX cat $kfcFreqTable | $BUSYBOX tr '\n' ' ' | $BUSYBOX awk '{print $NF}')

      if [ "$minFreq" -lt "$maxFreq" ]; then
        echo "$minFreq " >>$MIN_MAX_FREQ
        echo "$maxFreq " >>$MIN_MAX_FREQ
      elif [ "$minFreq" -gt "$maxFreq" ]; then
        echo "$maxFreq " >>$MIN_MAX_FREQ
        echo "$minFreq " >>$MIN_MAX_FREQ
      fi
    fi
    unset minFreq
    unset maxFreq

    if [ -e $cpuFreqTable ]; then
      minFreq=$($BUSYBOX cat $cpuFreqTable | $BUSYBOX tr '\n' ' ' | $BUSYBOX awk '{print $1}')
      maxFreq=$($BUSYBOX cat $cpuFreqTable | $BUSYBOX tr '\n' ' ' | $BUSYBOX awk '{print $NF}')

      if [ "$minFreq" -lt "$maxFreq" ]; then
        echo "$minFreq " >>$MIN_MAX_FREQ
        echo "$maxFreq " >>$MIN_MAX_FREQ
      elif [ "$minFreq" -gt "$maxFreq" ]; then
        echo "$maxFreq " >>$MIN_MAX_FREQ
        echo "$minFreq " >>$MIN_MAX_FREQ
      fi
    fi
    unset minFreq
    unset maxFreq
  fi

  sleep 0.5

  unset cluster0FreqTable
  unset cluster1FreqTable
  unset cluster2FreqTable
  unset kfcFreqTable
  unset cpuFreqTable
}

#######
# Method returns Min frequency of LITTLE, BIG and PRIME cores,
# also REGULAR frequency in a list taking min_max_freq list as argument
#######
getMinFreqList() {
  rm -rf $MIN_FREQ_LIST

  minMaxFreqSize=$($BUSYBOX cat $MIN_MAX_FREQ | $BUSYBOX tr '\n' ' ' | $BUSYBOX wc -w)

  i=1
  while [ $i -le "$minMaxFreqSize" ]; do

    minFreqList=$($BUSYBOX cat $MIN_MAX_FREQ | $BUSYBOX tr '\n' ' ' | $BUSYBOX awk '{print $'$i'}')

    echo "$minFreqList " >>$MIN_FREQ_LIST

    i=$((i + 2))
  done

  sleep 0.5

  unset minMaxFreqSize
  unset i
  unset minFreqList
}

#######
# Method returns Max frequency of LITTLE, BIG and PRIME cores,
# also REGULAR frequency in a list taking min_max_freq list as argument
#######
getMaxFreqList() {
  rm -rf $MAX_FREQ_LIST

  minMaxFreqSize=$($BUSYBOX cat $MIN_MAX_FREQ | $BUSYBOX tr '\n' ' ' | $BUSYBOX wc -w)

  i=2
  while [ $i -le "$minMaxFreqSize" ]; do

    maxFreqList=$($BUSYBOX cat $MIN_MAX_FREQ | $BUSYBOX tr '\n' ' ' | $BUSYBOX awk '{print $'$i'}')

    echo "$maxFreqList " >>$MAX_FREQ_LIST

    i=$((i + 2))
  done

  sleep 0.5

  unset minMaxFreqSize
  unset i
  unset maxFreqList
}

#######
# Logical cores detect the parent core of the cluster
#######
logicalCores() {
  rm -rf $LOGICAL_CORE

  #####
  # Get the logical core over affected cpu list
  #####
  core_count=$($BUSYBOX cat $CPU_CORE_COUNT)
  # Counter
  core=0

  # Core 0 is always affected
  echo "0 " >$LOGICAL_CORE

  while [ $core -le $core_count ]; do
    affected_cpus=/sys/devices/system/cpu/cpu$core/cpufreq/affected_cpus

    if [ -e $affected_cpus ]; then
      getAffectedCPU=$($BUSYBOX cat $affected_cpus | $BUSYBOX tr '\n' ' ' | $BUSYBOX awk '{print $1}')

      getLastInputAffectedCPU=$($BUSYBOX cat $LOGICAL_CORE | $BUSYBOX tr '\n' ' ' | $BUSYBOX awk '{print $NF}')

      if [ ! $getLastInputAffectedCPU -eq $getAffectedCPU ]; then
        echo "$getAffectedCPU " >>$LOGICAL_CORE
      fi
    fi

    core=$((core + 1))
  done

  sleep 0.5

  unset core_count
  unset core
  unset affected_cpus
  unset getAffectedCPU
  unset getLastInputAffectedCPU
}

##########
# Lets create a Integer list containing non-repeating values of max_frequency
##########
getUniqueFreq() {
  rm -rf $UNIQUE_FREQ

  sleep 0.2

  $BUSYBOX cat $MAX_FREQ_LIST | $BUSYBOX uniq >$UNIQUE_FREQ

  sleep 0.5
}

##########
# coreGetter returns a list with parent core of clusters in descending order PRIME to LITTLE
##########
coreGetter() {

  rm -rf $CORE_GETTER

  prime=0
  big=0
  little=0

  logicalCoresListSize=$($BUSYBOX cat $LOGICAL_CORE | $BUSYBOX tr '\n' ' ' | $BUSYBOX wc -w)
  uniqueFreqListSize=$($BUSYBOX cat $UNIQUE_FREQ | $BUSYBOX tr '\n' ' ' | $BUSYBOX wc -w)
  real_core_count=$($BUSYBOX cat $REAL_CPU_CORE_COUNT)

  if [ "$logicalCoresListSize" -eq 3 ] && [ "$uniqueFreqListSize" -eq 3 ]; then

    firtsHighestFreq=$($BUSYBOX cat $UNIQUE_FREQ | $BUSYBOX sort -n | $BUSYBOX tail -1 | $BUSYBOX head -1)
    secondHighestFreq=$($BUSYBOX cat $UNIQUE_FREQ | $BUSYBOX sort -n | $BUSYBOX tail -2 | $BUSYBOX head -1)
    thirdHighestFreq=$($BUSYBOX cat $UNIQUE_FREQ | $BUSYBOX sort -n | $BUSYBOX tail -3 | $BUSYBOX head -1)

    getPrimeCluster="$(grep -n "$firtsHighestFreq" $UNIQUE_FREQ | head -n 1 | cut -d: -f1)"
    getBigCluster="$(grep -n "$secondHighestFreq" $UNIQUE_FREQ | head -n 1 | cut -d: -f1)"
    getLittleCluster="$(grep -n "$thirdHighestFreq" $UNIQUE_FREQ | head -n 1 | cut -d: -f1)"

    prime=$($BUSYBOX cat $LOGICAL_CORE | $BUSYBOX tr '\n' ' ' | $BUSYBOX awk '{print $'$getPrimeCluster'}')
    big=$($BUSYBOX cat $LOGICAL_CORE | $BUSYBOX tr '\n' ' ' | $BUSYBOX awk '{print $'$getBigCluster'}')
    little=$($BUSYBOX cat $LOGICAL_CORE | $BUSYBOX tr '\n' ' ' | $BUSYBOX awk '{print $'$getLittleCluster'}')

    $BUSYBOX printf "$prime\n$big\n$little" >$CORE_GETTER

  elif
    [ "$logicalCoresListSize" -eq 2 ] && [ "$uniqueFreqListSize" -eq 2 ]
  then

    firtsHighestFreq=$($BUSYBOX cat $UNIQUE_FREQ | $BUSYBOX sort -n | $BUSYBOX tail -1 | $BUSYBOX head -1)
    secondHighestFreq=$($BUSYBOX cat $UNIQUE_FREQ | $BUSYBOX sort -n | $BUSYBOX tail -2 | $BUSYBOX head -1)

    getBigCluster="$($BUSYBOX grep -n "$firtsHighestFreq" $UNIQUE_FREQ | $BUSYBOX head -n 1 | $BUSYBOX cut -d: -f1)"
    getLittleCluster="$($BUSYBOX grep -n "$secondHighestFreq" $UNIQUE_FREQ | $BUSYBOX head -n 1 | $BUSYBOX cut -d: -f1)"

    big=$($BUSYBOX cat $LOGICAL_CORE | $BUSYBOX tr '\n' ' ' | $BUSYBOX awk '{print $'$getBigCluster'}')
    little=$($BUSYBOX cat $LOGICAL_CORE | $BUSYBOX tr '\n' ' ' | $BUSYBOX awk '{print $'$getLittleCluster'}')

    $BUSYBOX printf "$big\n$little" >$CORE_GETTER

    getBig=$($BUSYBOX cat $CORE_GETTER | $BUSYBOX tr '\n' ' ' | $BUSYBOX awk '{print $1}')
    getLittle=$($BUSYBOX cat $CORE_GETTER | $BUSYBOX tr '\n' ' ' | $BUSYBOX awk '{print $2}')

    # This is some dirty getter of inverted cluster
    # for now works well
    if [ $getBig -gt $getLittle ]; then
      littleCoresCount=$((getBig))
      bigCoresCount=$((real_core_count - getBig))
    else
      littleCoresCount=$((real_core_count - getLittle))
      bigCoresCount=$((getLittle))
    fi

    echo "$bigCoresCount" >$BIG_CORES_COUNT
    echo "$littleCoresCount" >$LITTLE_CORES_COUNT

  else
    $BUSYBOX cat $LOGICAL_CORE | $BUSYBOX tr ' ' '\n' | $BUSYBOX sort -n -r | $BUSYBOX uniq >$CORE_GETTER

  fi

  unset logicalCoresListSize
  unset uniqueFreqListSize
  unset prime
  unset big
  unset little
  unset firtsHighestFreq
  unset secondHighestFreq
  unset thirdHighestFreq
  unset getPrimeCluster
  unset getBigCluster
  unset getLittleCluster
  sleep 0.5

}

######
# Function to call other cpu detection related functons
######
cpuDetect() {
  getCPUcoreCount
  getMinAndMaxFreq
  getMinFreqList
  getMaxFreqList
  logicalCores
  getUniqueFreq
  coreGetter
}

#######
# Cpuset tuner used to tune up cpusets according to different CPU structures
#######
cpusetTuner() {
  # Starting cpu_detect
  sendToLog "Starting CPU detect..."
  cpuDetect

  core_getter_list_size=$($BUSYBOX cat $CORE_GETTER | $BUSYBOX tr '\n' ' ' | $BUSYBOX wc -w)
  core_count=$($BUSYBOX cat $CPU_CORE_COUNT)
  real_core_count=$($BUSYBOX cat $REAL_CPU_CORE_COUNT)

  if [ "$core_getter_list_size" -eq 3 ]; then
    getPrime=$($BUSYBOX cat $CORE_GETTER | $BUSYBOX tr '\n' ' ' | $BUSYBOX awk '{print $1}')
    getBig=$($BUSYBOX cat $CORE_GETTER | $BUSYBOX tr '\n' ' ' | $BUSYBOX awk '{print $2}')
    getLittle=$($BUSYBOX cat $CORE_GETTER | $BUSYBOX tr '\n' ' ' | $BUSYBOX awk '{print $3}')

    # This shows real numbers, for usage we should use n-1
    # e.g. CPU have 4 LITTLE(0-3) and 3 BIG (4-6) and 1 PRIME (7-7)
    littleCoresCount=$((getBig))
    bigCoresCount=$((getPrime - getBig))
    primeCoresCount=$((real_core_count - getPrime))

    sendToLog "Setting up cpuset for $littleCoresCount(0-$((getBig - 1))) LITTLE CPU cores, $bigCoresCount($getBig-$((getPrime - 1))) BIG CPU cores and $primeCoresCount($getPrime-$core_count) PRIME CPU cores"

    # 0-1 2-5 6-9
    if [ $littleCoresCount -eq 2 ] && [ $bigCoresCount -eq 4 ] && [ $primeCoresCount -eq 4 ]; then
      foreground="0-8"
      topApp="0-9"
      background="0-1"
      systemBackround="0-1"

      validConfig=true

    # 0-3 4-5 6-7
    elif [ $littleCoresCount -eq 4 ] && [ $bigCoresCount -eq 2 ] && [ $primeCoresCount -eq 2 ]; then
      foreground="0-6"
      topApp="0-7"
      background="0-2"
      systemBackround="0-3"

      validConfig=true

    # 0-3 4-6 7
    elif [ $littleCoresCount -eq 4 ] && [ $bigCoresCount -eq 3 ] && [ $primeCoresCount -eq 1 ]; then
      foreground="0-6"
      topApp="0-7"
      background="0-2"
      systemBackround="0-3"

      validConfig=true
    else
      sendToLog "Cannot set cpuset for this CPU configuration"

      validConfig=false
    fi

  elif [ "$core_getter_list_size" -eq 2 ]; then
    # This shows real numbers, for usage we should use n-1
    # e.g. CPU have 6 LITTLE(0-5) and 2 BIG (6-7)
    littleCoresCount=$($BUSYBOX cat $LITTLE_CORES_COUNT)
    bigCoresCount=$($BUSYBOX cat $BIG_CORES_COUNT)

    sendToLog "Setting up cpuset for $littleCoresCount LITTLE CPU cores and $bigCoresCount BIG CPU cores"

    # 0-1 2-3
    if [ $littleCoresCount -eq 2 ] && [ $bigCoresCount -eq 2 ]; then
      foreground="0-2"
      topApp="0-3"
      background="0-1"
      systemBackround="0-2"

      validConfig=true

    # 0-3 4-5
    elif [ $littleCoresCount -eq 4 ] && [ $bigCoresCount -eq 2 ]; then
      foreground="0-4"
      topApp="0-5"
      background="0-2"
      systemBackround="0-3"

      validConfig=true

    # 0-3 4-7
    elif [ $littleCoresCount -eq 4 ] && [ $bigCoresCount -eq 4 ]; then
      foreground="0-6"
      topApp="0-7"
      background="0-2"
      systemBackround="0-3"

      validConfig=true

    # 0-5 6-7
    elif [ $littleCoresCount -eq 6 ] && [ $bigCoresCount -eq 2 ]; then
      foreground="0-6"
      topApp="0-7"
      background="0-2"
      systemBackround="0-5"

      validConfig=true
    else
      sendToLog "Cannot set cpuset for this CPU configuration"

      validConfig=false
    fi
  else
    getRegular=$($BUSYBOX cat $CORE_GETTER | $BUSYBOX tr '\n' ' ' | $BUSYBOX awk '{print $1}')

    sendToLog "Setting up cpuset for $real_core_count REGULAR CPU cores"

    # 0-3
    if [ "$real_core_count" -eq 4 ]; then
      foreground="0-2"
      topApp="0-3"
      background="0-1"
      systemBackround="0-2"

      validConfig=true

    # 0-5
    elif [ "$real_core_count" -eq 6 ]; then
      foreground="0-4"
      topApp="0-5"
      background="0-2"
      systemBackround="0-3"

      validConfig=true

    # 0-7
    elif [ "$real_core_count" -eq 8 ]; then
      foreground="0-6"
      topApp="0-7"
      background="0-2"
      systemBackround="0-5"

      validConfig=true

    # 0-9
    elif [ "$real_core_count" -eq 10 ]; then
      foreground="0-8"
      topApp="0-9"
      background="0-2"
      systemBackround="0-5"

      validConfig=true
    else
      sendToLog "Cannot set cpuset for this CPU configuration"

      validConfig=false
    fi
  fi

  if [ $validConfig = true ]; then
    # update cpuset now that processors are up
    # Foreground should contain most cores
    if [ -e /dev/cpuset/foreground/cpus ]; then
      write /dev/cpuset/foreground/cpus "$foreground"
      sendToLog "cpuset for foreground set: $foreground"
    fi

    # top-app usualy all the cpus
    if [ -e /dev/cpuset/top-app/cpus ]; then
      write /dev/cpuset/top-app/cpus "$topApp"
      sendToLog "cpuset for top-app set: $topApp"
    fi

    # background contains a small subset so lower cores as possible
    if [ -e /dev/cpuset/background/cpus ]; then
      write /dev/cpuset/background/cpus "$background"
      sendToLog "cpuset for background set: $background"
    fi

    # add system-background cpuset, a new cpuset for system services
    # that should not run on larger cores
    # system-background is for system tasks that should only run on
    # little cores, not on bigs to be used only by init
    # so we are using about the half of the cpu cores
    if [ -e /dev/cpuset/system-background/cpus ]; then
      write /dev/cpuset/system-background/cpus "$systemBackround"
      sendToLog "cpuset for system-background set: $systemBackround"
    fi
  fi

}

#
# CPU Optimization
#

sendToLog "Applying performance CPU optimization..."

if [ -e "/sys/devices/system/cpu/cpuidle/use_deepest_state" ]; then
  write /sys/devices/system/cpu/cpuidle/use_deepest_state "1"
  sendToLog "Enable deepest CPU idle state"
fi

# Disable krait voltage boost
if [ -e "/sys/module/acpuclock_krait/parameters/boost" ]; then
  write /sys/module/acpuclock_krait/parameters/boost "Y"
  sendToLog "Enable Krait voltage boost"
fi

if [ -e "/sys/module/workqueue/parameters/power_efficient" ]; then
  lockFile /sys/module/workqueue/parameters/power_efficient "N"
  sendToLog "Power-save workqueues disabled, scheduling workqueues on awake CPUs to save power."
fi

sched_boost=/proc/sys/kernel/sched_boost
if [ -e $sched_boost ]; then
  write $sched_boost "0"
  sendToLog "sched_boost=0"
fi

perf_cpu_time_max_percent=/proc/sys/kernel/perf_cpu_time_max_percent
if [ -e $perf_cpu_time_max_percent ]; then
  write $perf_cpu_time_max_percent "5"
  sendToLog "perf_cpu_time_max_percent=5"
fi

sched_autogroup_enabled=/proc/sys/kernel/sched_autogroup_enabled
if [ -e $sched_autogroup_enabled ]; then
  write $sched_autogroup_enabled "1"
  sendToLog "sched_autogroup_enabled=1"
fi

sched_child_runs_first=/proc/sys/kernel/sched_child_runs_first
if [ -e $sched_child_runs_first ]; then
  write $sched_child_runs_first "1"
  sendToLog "sched_child_runs_first=1"
fi

sched_tunable_scaling=/proc/sys/kernel/sched_tunable_scaling
if [ -e $sched_tunable_scaling ]; then
  write $sched_tunable_scaling "0"
  sendToLog "sched_tunable_scaling=0"
fi

sched_latency_ns=/proc/sys/kernel/sched_latency_ns
if [ -e $sched_latency_ns ]; then
  write $sched_latency_ns "1000000"
  sendToLog "sched_latency_ns=1000000"
fi

sched_min_granularity_ns=/proc/sys/kernel/sched_min_granularity_ns
if [ -e $sched_min_granularity_ns ]; then
  write $sched_min_granularity_ns "130000"
  sendToLog "sched_min_granularity_ns=130000"
fi

sched_wakeup_granularity_ns=/proc/sys/kernel/sched_wakeup_granularity_ns
if [ -e $sched_wakeup_granularity_ns ]; then
  write $sched_wakeup_granularity_ns "750000"
  sendToLog "sched_wakeup_granularity_ns=750000"
fi

sched_migration_cost_ns=/proc/sys/kernel/sched_migration_cost_ns
if [ -e $sched_migration_cost_ns ]; then
  write $sched_migration_cost_ns "3000000"
  sendToLog "sched_migration_cost_ns=3000000"
fi

sched_min_task_util_for_colocation=/proc/sys/kernel/sched_min_task_util_for_colocation
if [ -e $sched_min_task_util_for_colocation ]; then
  write $sched_min_task_util_for_colocation "0"
  sendToLog "sched_min_task_util_for_colocation=0"
fi

sched_nr_migrate=/proc/sys/kernel/sched_nr_migrate
if [ -e $sched_nr_migrate ]; then
  write $sched_nr_migrate "8"
  sendToLog "sched_nr_migrate=8"
fi

sched_schedstats=/proc/sys/kernel/sched_schedstats
if [ -e $sched_schedstats ]; then
  write $sched_schedstats "0"
  sendToLog "sched_schedstats=0"
fi

# Disable touch boost
touchboost=/sys/module/msm_performance/parameters/touchboost
if [ -e $touchboost ]; then
  write $touchboost "0"
  sendToLog "$touchboost=0"
fi

touch_boost=/sys/power/pnpmgr/touch_boost
if [ -e $touch_boost ]; then
  write $touch_boost "N"
  sendToLog "$touch_boost=N"
fi

#Disable CPU Boost
boost_ms=/sys/module/cpu_boost/parameters/boost_ms
if [ -e $boost_ms ]; then
  write $boost_ms "N"
  sendToLog "$boost_ms=N"
fi

sched_boost_on_input=/sys/module/cpu_boost/parameters/sched_boost_on_input
if [ -e $sched_boost_on_input ]; then
  write $sched_boost_on_input "N"
  sendToLog "$sched_boost_on_input=N"
fi

stune_background_prefer_idle="/dev/stune/background/schedtune.prefer_idle"
if [ -e $stune_background_prefer_idle ]; then
  write $stune_background_prefer_idle "0"
  sendToLog "$stune_background_prefer_idle=0"
fi

stune_foreground_prefer_idle="/dev/stune/foreground/schedtune.prefer_idle"
if [ -e $stune_foreground_prefer_idle ]; then
  write $stune_foreground_prefer_idle "0"
  sendToLog "$stune_foreground_prefer_idle=0"
fi

stune_topapp_prefer_idle="/dev/stune/top-app/schedtune.prefer_idle"
if [ -e $stune_topapp_prefer_idle ]; then
  write $stune_topapp_prefer_idle "1"
  sendToLog "$stune_topapp_prefer_idle=1"
fi

stune_topapp_schedtune_boost="/dev/stune/top-app/schedtune.boost"
if [ -e $stune_topapp_schedtune_boost ]; then
  write $stune_topapp_schedtune_boost 1
  sendToLog "$stune_topapp_schedtune_boost=1"
fi

#stune_global_prefer_idle="/dev/stune/schedtune.prefer_idle"
#if [ -e $stune_global_prefer_idle ]; then
#  write $stune_global_prefer_idle "0"
#  sendToLog "$stune_global_prefer_idle=0"
#fi

#stune_rt_prefer_idle="/dev/stune/rt/schedtune.prefer_idle"
#if [ -e $stune_rt_prefer_idle ]; then
#  write $stune_rt_prefer_idle "0"
#  sendToLog "$stune_rt_prefer_idle=0"
#fi

for cpu in /sys/devices/system/cpu/cpu*/cpufreq
do
  available_governors="$(cat "$cpu/scaling_available_governors")"

case "$available_governors" in
*schedutil*)
  write "$cpu/scaling_governor" "schedutil"
  ;;
*interactive*)
  write "$cpu/scaling_governor" "interactive"
  ;;
*) echo no ;;
esac
done

cpusetTuner

sendToLog "Successfully applied performance CPU optimization"
sendToLog "$divider"
