navyxliu

there's another bug in remove-dead-values. 
the problem is liveness analysis depends on  mlir::dataflow::DeadCodeAnalysis. 
without any reference of @main2, it doesn't participate progation of liveness. As a result, it has no idea arg0 and %arg1 of @immutable_fn_return_void_with_unused_argument. 

RDV needs to delete @main2 entirely. 

➜  build git:(backward_remove_dead_values) cat in3.mlir
// /bin/mlir-opt --remove-dead-values --debug-only=remove-dead-values --debug-only=liveness-analysis  --debug-only=dataflow ./in3.mlir
  func.func public @immutable_fn_return_void_with_unused_argument(%arg0: i32, %arg1: memref<4xf32>) -> () {
    return

navyxliu

input.mlir
```
module @return_void_with_unused_argument {
  // the function is immutable because it is public.
  func.func public @immutable_fn_return_void_with_unused_argument(%arg0: i32, %unused: i32) -> () {
    %sum = arith.addi %arg0, %arg0 : i32
    %c0 = arith.constant 0 : index
    %buf = memref.alloc() : memref<1xi32>
    memref.store %sum, %buf[%c0] : memref<1xi32>
    return

navyxliu

module {
  func.func @local_sparse_attention_kernel_03_bf(%arg0: i32, %arg1: i32, %arg2: i32, %arg3: i32, %arg4: i32, %arg5: i32, %arg6: i32, %arg7: !tt.ptr<f16>, %arg8: !tt.ptr<f16>, %arg9: !tt.ptr<f16>, %arg10: !tt.ptr<f16>) {
    %c16_i32 = arith.constant 16 : i32
    %cst = arith.constant 0.000000e+00 : f32
    %cst_1 = arith.constant 0xFF800000 : f32
    %c0_i32 = arith.constant 0 : i32
    %c1_i32 = arith.constant 1 : i32

    %alloc_5 = memref.alloc() {alignment = 64 : i64} : memref<1x128xf16>
    %alloc_7 = memref.alloc() {alignment = 64 : i64} : memref<1x128xf32>

navyxliu

// ./build/linux-x86_64-server-fastdebug/jdk/bin/java -XX:+PrintCompilation -XX:CompileCommand=compileonly,EmptyString::main  -XX:CompileCommand=quiet -Xbatch -XX:+PrintOptoAssembly -XX:CompileCommand=IGVPrintLevel,EmptyString::main,3 EmptyString
class EmptyString {
  public static void main(String[] args) {
        String msg = "";
        int x = 0;

        for (int i = 0; i < 300_000; ++i)  {
          if (msg.length() > 0) {
            x++;

navyxliu

#!/usr/bin/env ruby
lines = ARGF.readlines
total = 0
lines.each do |line|
  if line =~ /(\d+)\smessages dropped due to async logging/
    num = $1.to_i
    total = total + num
    #print line
  end
end

navyxliu

// java -XX:CompileOnly='UnderProfiledSubprocedure.foo' -XX:+PrintInlining -XX:+PrintCompilation -XX:CompileCommand=quiet -Xbatch UnderProfiledSubprocedure
import java.util.ArrayList;

class UnderProfiledSubprocedure {
    private static int ODD = 100;

    public void foo(boolean cond) {
        var x = new ArrayList<Integer>();
        if (cond) {   // the branch is only taken by ODD
            x.add(0); // ArrayList::add(E) is the subprocedure. it will call ArrayList::add(E, Object[], int)

navyxliu

; my handy scripts on MacOS
function realpath() {
    [[ $1 = /* ]] && echo "$1" || echo "$PWD/${1#./}"
}

function jdk_select() {
    if [ -e $1/bin/java ]; then
        P=$(realpath $1)
        export JAVA_HOME=$P
        export PATH=$JAVA_HOME/bin:$PATH

navyxliu

troubleshooting

➜  WebKit git:(main) ./WebKitBuild/Debug/jsc
dyld[8692]: Symbol not found: __ZN3JSC27retrieveTypeImportAttributeEPNS_14JSGlobalObjectERKN3WTF7HashMapINS2_6RefPtrINS2_17UniquedStringImplENS2_12RawPtrTraitsIS5_EENS2_21DefaultRefDerefTraitsIS5_EEEENS2_6StringENS2_11DefaultHashISA_EENS2_10HashTraitsISA_EENSE_ISB_EENS2_15HashTableTraitsEEE
  Referenced from: <BD3D10DA-F74B-3755-8B54-29D1F10163E5> /Users/xxinliu/Devel/WebKit/WebKitBuild/Debug/jsc (built for macOS 14.0 which is newer than running OS)
  Expected in:     <957522FA-9B44-3C8F-9BD4-A209C728B133> /System/Library/Frameworks/JavaScriptCore.framework/Versions/A/JavaScriptCore
[1]    8692 abort      ./WebKitBuild/Debug/jsc

The problem here is JSC depends on WTF(who would name its library that? it seems the acronym of webkit's template framework). Dynamic loader has difficulty to resolve this symbol in WTF. we need to teach dynamic laoder to get from what you built

navyxliu

//  java -XX:CompileCommand=quiet -XX:CompileCommand=compileonly,RelockInDeopt::snippet2 -XX:-TieredCompilation -XX:-UseOnStackReplacement -XX:+PrintCompilation -XX:+TraceDeoptimization -XX:+PrintEliminateLocks -XX:+PrintDeoptimizationDetails -XX:-PrintInlining -Xbatch -XX:+PrintEliminateAllocations RelockInDeopt
class RelockInDeopt {
        static int staticInt = 0;
        static Object staticObj = null;

        public static void snippet2() {
         Object escaped = new Object();
         Object nonEscaped = new Object();

                 synchronized (nonEscaped) {

navyxliu

Aggressive liveness for unstable_if traps

Background:

C2 is a speculative compiler. When it encounters a conditional branch and profiling data suggest that the control is highly likely to take one path, parser intends to prune the other path and leave a runtime stub uncommon_trap. We refer to it as “unstable_if trap” because the reason of this stub is unstable_if. If the rare case does happen, the trap triggers deoptimization. HotSpot realizes that current profiling data do not hold up and destroys this compilation. The execution returns to interpreter. Presumably, the upcoming compilation of this method will correct itself with updated profiling data.

Bci(byte code index) in JVM is analogous to the PC(program counter) of a physical processor. It points to the current bytecode in interpreter. Because an uncommon_trap stub punts to interpreter, it must restore the interpreter state in JVM. Restoring the interpreter state means that all variables live at the current bci must have cor