feat: add selection-sort

Author: HarshitaKalani

pydatastructs/linear_data_structures/_backend/cpp/algorithms/algorithms.cpp

@@ -10,6 +10,8 @@ static PyMethodDef algorithms_PyMethodDef[] = {
      METH_VARARGS | METH_KEYWORDS, ""},
     {"bubble_sort_llvm",  (PyCFunction)bubble_sort_llvm,
      METH_VARARGS | METH_KEYWORDS, ""},
+    {"selection_sort_llvm",  (PyCFunction)selection_sort_llvm,
+     METH_VARARGS | METH_KEYWORDS, ""},
     {"selection_sort", (PyCFunction) selection_sort,
      METH_VARARGS | METH_KEYWORDS, ""},
     {"insertion_sort", (PyCFunction) insertion_sort,

pydatastructs/linear_data_structures/_backend/cpp/algorithms/llvm_algorithms.py

@@ -41,6 +41,159 @@ def get_bubble_sort_ptr(dtype: str) -> int:
 
     return _materialize(dtype)
 
+
+def get_selection_sort_ptr(dtype: str) -> int:
+    dtype = dtype.lower().strip()
+    if dtype not in _SUPPORTED:
+        raise ValueError(f"Unsupported dtype '{dtype}'. Supported: {list(_SUPPORTED)}")
+
+    return _materialize_selection(dtype)
+
+
+def _build_selection_sort_ir(dtype: str) -> str:
+    if dtype not in _SUPPORTED:
+        raise ValueError(f"Unsupported dtype '{dtype}'. Supported: {list(_SUPPORTED)}")
+
+    T, _ = _SUPPORTED[dtype]
+    i32 = ir.IntType(32)
+    i64 = ir.IntType(64)
+
+    mod = ir.Module(name=f"selection_sort_{dtype}_module")
+    fn_name = f"selection_sort_{dtype}"
+
+    fn_ty = ir.FunctionType(ir.VoidType(), [T.as_pointer(), i32])
+    fn = ir.Function(mod, fn_ty, name=fn_name)
+
+    arr, n = fn.args
+    arr.name, n.name = "arr", "n"
+
+    b_entry = fn.append_basic_block("entry")
+    b_outer = fn.append_basic_block("outer")
+    b_find_min = fn.append_basic_block("find_min")
+    b_inner = fn.append_basic_block("inner")
+    b_update_min = fn.append_basic_block("update_min")
+    b_inc_j = fn.append_basic_block("inc_j")
+    b_check_swap = fn.append_basic_block("check_swap")
+    b_do_swap = fn.append_basic_block("do_swap")
+    b_outer_latch = fn.append_basic_block("outer.latch")
+    b_exit = fn.append_basic_block("exit")
+
+    b = ir.IRBuilder(b_entry)
+
+    cond_trivial = b.icmp_signed("<=", n, ir.Constant(i32, 1))
+    b.cbranch(cond_trivial, b_exit, b_outer)
+
+    b.position_at_end(b_outer)
+    i_phi = b.phi(i32, name="i")
+    i_phi.add_incoming(ir.Constant(i32, 0), b_entry)
+
+    n_minus_1 = b.sub(n, ir.Constant(i32, 1), name="n_minus_1")
+    cond_outer = b.icmp_signed("<", i_phi, n_minus_1)
+    b.cbranch(cond_outer, b_find_min, b_exit)
+
+    b.position_at_end(b_find_min)
+    min_idx = b.alloca(i32, name="min_idx")
+    b.store(i_phi, min_idx)
+    j_init = b.add(i_phi, ir.Constant(i32, 1), name="j_init")
+    b.branch(b_inner)
+
+    b.position_at_end(b_inner)
+    j_phi = b.phi(i32, name="j")
+    j_phi.add_incoming(j_init, b_find_min)
+
+    cond_inner = b.icmp_signed("<", j_phi, n)
+    b.cbranch(cond_inner, b_update_min, b_check_swap)
+
+    b.position_at_end(b_update_min)
+    j64 = b.sext(j_phi, i64)
+    min_idx_val = b.load(min_idx)
+    min64 = b.sext(min_idx_val, i64)
+
+    ptr_j = b.gep(arr, [j64], inbounds=True)
+    ptr_min = b.gep(arr, [min64], inbounds=True)
+    val_j = b.load(ptr_j)
+    val_min = b.load(ptr_min)
+
+    if isinstance(T, ir.IntType):
+        cmp_less = b.icmp_signed("<", val_j, val_min)
+    else:
+        cmp_less = b.fcmp_ordered("<", val_j, val_min, fastmath=True)
+
+    b.cbranch(cmp_less, b_inc_j, b_inc_j)
+
+    b.position_at_end(b_inc_j)
+    cur_min = b.load(min_idx)
+    new_min = b.select(cmp_less, j_phi, cur_min)
+    b.store(new_min, min_idx)
+    j_next = b.add(j_phi, ir.Constant(i32, 1), name="j_next")
+    j_phi.add_incoming(j_next, b_inc_j)
+    b.branch(b_inner)
+
+    b.position_at_end(b_check_swap)
+    final_min = b.load(min_idx)
+    need_swap = b.icmp_signed("!=", final_min, i_phi)
+    b.cbranch(need_swap, b_do_swap, b_outer_latch)
+
+    b.position_at_end(b_do_swap)
+    i64_idx = b.sext(i_phi, i64)
+    min64_idx = b.sext(final_min, i64)
+    ptr_i = b.gep(arr, [i64_idx], inbounds=True)
+    ptr_min2 = b.gep(arr, [min64_idx], inbounds=True)
+    val_i = b.load(ptr_i)
+    val_min2 = b.load(ptr_min2)
+    b.store(val_min2, ptr_i)
+    b.store(val_i, ptr_min2)
+    b.branch(b_outer_latch)
+
+    b.position_at_end(b_outer_latch)
+    i_next = b.add(i_phi, ir.Constant(i32, 1), name="i_next")
+    i_phi.add_incoming(i_next, b_outer_latch)
+    b.branch(b_outer)
+
+    b.position_at_end(b_exit)
+    b.ret_void()
+
+    return str(mod)
+
+
+def _materialize_selection(dtype: str) -> int:
+    _ensure_target_machine()
+
+    key = f"selection_sort_{dtype}"
+    if key in _fn_ptr_cache:
+        return _fn_ptr_cache[key]
+
+    try:
+        llvm_ir = _build_selection_sort_ir(dtype)
+        mod = binding.parse_assembly(llvm_ir)
+        mod.verify()
+
+        try:
+            pm = binding.ModulePassManager()
+            pm.add_instruction_combining_pass()
+            pm.add_reassociate_pass()
+            pm.add_gvn_pass()
+            pm.add_cfg_simplification_pass()
+            pm.run(mod)
+        except AttributeError:
+            pass
+
+        engine = binding.create_mcjit_compiler(mod, _target_machine)
+        engine.finalize_object()
+        engine.run_static_constructors()
+
+        addr = engine.get_function_address(f"selection_sort_{dtype}")
+        if not addr:
+            raise RuntimeError(f"Failed to get address for selection_sort_{dtype}")
+
+        _fn_ptr_cache[key] = addr
+        _engines[key] = engine
+
+        return addr
+
+    except Exception as e:
+        raise RuntimeError(f"Failed to materialize selection function for dtype {dtype}: {e}")
+
 def _build_bubble_sort_ir(dtype: str) -> str:
     if dtype not in _SUPPORTED:
         raise ValueError(f"Unsupported dtype '{dtype}'. Supported: {list(_SUPPORTED)}")