add llvm implementation for insertion sort

HarshitaKalani · HarshitaKalani · commit 04bbdc0aa554 · 2025-10-14T20:13:58.000+05:30
diff --git a/pydatastructs/linear_data_structures/_backend/cpp/algorithms/algorithms.cpp b/pydatastructs/linear_data_structures/_backend/cpp/algorithms/algorithms.cpp
@@ -14,6 +14,8 @@ static PyMethodDef algorithms_PyMethodDef[] = {
      METH_VARARGS | METH_KEYWORDS, ""},
     {"insertion_sort", (PyCFunction) insertion_sort,
      METH_VARARGS | METH_KEYWORDS, ""},
+    {"insertion_sort_llvm",  (PyCFunction)insertion_sort_llvm,
+     METH_VARARGS | METH_KEYWORDS, ""},
     {"is_ordered", (PyCFunction) is_ordered,
      METH_VARARGS | METH_KEYWORDS, ""},
     {"linear_search", (PyCFunction) linear_search,
diff --git a/pydatastructs/linear_data_structures/_backend/cpp/algorithms/llvm_algorithms.py b/pydatastructs/linear_data_structures/_backend/cpp/algorithms/llvm_algorithms.py
@@ -39,7 +39,7 @@ def get_bubble_sort_ptr(dtype: str) -> int:
     if dtype not in _SUPPORTED:
         raise ValueError(f"Unsupported dtype '{dtype}'. Supported: {list(_SUPPORTED)}")
 
-    return _materialize(dtype)
+    return _materialize(dtype, "bubble")
 
 def _build_bubble_sort_ir(dtype: str) -> str:
     if dtype not in _SUPPORTED:
@@ -131,14 +131,127 @@ def _build_bubble_sort_ir(dtype: str) -> str:
 
     return str(mod)
 
-def _materialize(dtype: str) -> int:
+def get_insertion_sort_ptr(dtype: str) -> int:
+    """Get function pointer for insertion sort with specified dtype."""
+    dtype = dtype.lower().strip()
+    if dtype not in _SUPPORTED:
+        raise ValueError(f"Unsupported dtype '{dtype}'. Supported: {list(_SUPPORTED)}")
+    return _materialize(dtype, "insertion")
+
+def _build_insertion_sort_ir(dtype: str) -> str:
+    """Generate LLVM IR for insertion sort for the given dtype."""
+    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"insertion_sort_{dtype}_module")
+    fn_name = f"insertion_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_inner = fn.append_basic_block("inner")
+    b_latch = fn.append_basic_block("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, 1), b_entry)
+
+    cond_outer = b.icmp_signed("<", i_phi, n)
+    b.cbranch(cond_outer, b_inner, b_exit)
+
+    b.position_at_end(b_inner)
+    i64_cast = b.sext(i_phi, i64)
+
+    # key = arr[i]
+    ptr_i = b.gep(arr, [i64_cast])
+    key = b.load(ptr_i, name="key")
+
+    # j = i - 1
+    j = b.sub(i_phi, ir.Constant(i32, 1), name="j")
+
+    # while j >= 0 and arr[j] > key
+    loop_cond = fn.append_basic_block("loop_cond")
+    loop_body = fn.append_basic_block("loop_body")
+    loop_exit = fn.append_basic_block("loop_exit")
+
+    b.branch(loop_cond)
+    b.position_at_end(loop_cond)
+
+    j64 = b.sext(j, i64)
+    ptr_j = b.gep(arr, [j64])
+    val_j = b.load(ptr_j, name="val_j")
+
+    if isinstance(T, ir.IntType):
+        cmp1 = b.icmp_signed(">=", j, ir.Constant(i32, 0))
+        cmp2 = b.icmp_signed(">", val_j, key)
+    else:
+        cmp1 = b.icmp_signed(">=", j, ir.Constant(i32, 0))
+        cmp2 = b.fcmp_ordered(">", val_j, key)
+
+    cond = b.and_(cmp1, cmp2)
+    b.cbranch(cond, loop_body, loop_exit)
+
+    # loop body
+    b.position_at_end(loop_body)
+    jp1 = b.add(j, ir.Constant(i32, 1))
+    jp1_64 = b.sext(jp1, i64)
+    ptr_jp1 = b.gep(arr, [jp1_64])
+    b.store(val_j, ptr_jp1)
+
+    j_next = b.sub(j, ir.Constant(i32, 1))
+    j = j_next
+    b.branch(loop_cond)
+
+    # after loop: arr[j + 1] = key
+    b.position_at_end(loop_exit)
+    jp1_final = b.add(j, ir.Constant(i32, 1))
+    jp1_final_64 = b.sext(jp1_final, i64)
+    ptr_jp1_final = b.gep(arr, [jp1_final_64])
+    b.store(key, ptr_jp1_final)
+
+    b.branch(b_latch)
+
+    # outer latch
+    b.position_at_end(b_latch)
+    i_next = b.add(i_phi, ir.Constant(i32, 1))
+    i_phi.add_incoming(i_next, b_latch)
+    b.branch(b_outer)
+
+    b.position_at_end(b_exit)
+    b.ret_void()
+
+    return str(mod)
+
+def _materialize(dtype: str, algo: str) -> int:
     _ensure_target_machine()
 
-    if dtype in _fn_ptr_cache:
-        return _fn_ptr_cache[dtype]
+    key = f"{algo}_{dtype}"
+    if key in _fn_ptr_cache:
+        return _fn_ptr_cache[key]
 
     try:
-        llvm_ir = _build_bubble_sort_ir(dtype)
+        if algo == "bubble":
+            llvm_ir = _build_bubble_sort_ir(dtype)
+        elif algo == "insertion":
+            llvm_ir = _build_insertion_sort_ir(dtype)
+        else:
+            raise ValueError(f"Unsupported algorithm '{algo}'")
+
         mod = binding.parse_assembly(llvm_ir)
         mod.verify()
 
@@ -156,12 +269,12 @@ def _materialize(dtype: str) -> int:
         engine.finalize_object()
         engine.run_static_constructors()
 
-        addr = engine.get_function_address(f"bubble_sort_{dtype}")
+        addr = engine.get_function_address(f"{algo}_sort_{dtype}")
         if not addr:
-            raise RuntimeError(f"Failed to get address for bubble_sort_{dtype}")
+            raise RuntimeError(f"Failed to get address for {algo}_sort_{dtype}")
 
-        _fn_ptr_cache[dtype] = addr
-        _engines[dtype] = engine
+        _fn_ptr_cache[key] = addr
+        _engines[key] = engine
 
         return addr
 
diff --git a/pydatastructs/linear_data_structures/_backend/cpp/algorithms/quadratic_time_sort.hpp b/pydatastructs/linear_data_structures/_backend/cpp/algorithms/quadratic_time_sort.hpp
@@ -729,5 +729,207 @@ static PyObject* insertion_sort(PyObject* self, PyObject* args, PyObject* kwds)
     return args0;
 }
 
+static PyObject* insertion_sort_llvm(PyObject* self, PyObject* args, PyObject* kwds) {
+    static const char* kwlist[] = {"arr", "start", "end", "comp", "dtype", NULL};
+    PyObject* arr_obj = NULL;
+    PyObject* start_obj = NULL;
+    PyObject* end_obj = NULL;
+    PyObject* comp_obj = NULL;
+    const char* dtype_cstr = NULL;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|OOOs", (char**)kwlist,
+                                     &arr_obj, &start_obj, &end_obj, &comp_obj, &dtype_cstr)) {
+        return NULL;
+    }
+
+    Py_ssize_t arr_len = PyObject_Length(arr_obj);
+    if (arr_len < 0) {
+        return NULL;
+    }
+
+    int start = 0;
+    int end = (int)arr_len;
+    if (start_obj && start_obj != Py_None)
+        start = (int)PyLong_AsLong(start_obj);
+    if (end_obj && end_obj != Py_None)
+        end = (int)PyLong_AsLong(end_obj);
+
+    if (start < 0 || end > arr_len || start >= end) {
+        Py_RETURN_NONE;
+    }
+
+    bool is_dynamic = false;
+    PyObject* buffer_obj = arr_obj;
+    if (PyObject_HasAttrString(arr_obj, "_data")) {
+        buffer_obj = PyObject_GetAttrString(arr_obj, "_data");
+        is_dynamic = true;
+    } else {
+        Py_INCREF(buffer_obj);
+    }
+
+    if (!PySequence_Check(buffer_obj)) {
+        Py_DECREF(buffer_obj);
+        PyErr_SetString(PyExc_TypeError, "Expected a sequence or dynamic array");
+        return NULL;
+    }
+
+    PyObject* first = PySequence_GetItem(buffer_obj, 0);
+    if (!first) {
+        Py_DECREF(buffer_obj);
+        return NULL;
+    }
+
+    const char* inferred_dtype = dtype_cstr ? dtype_cstr : (
+        PyLong_Check(first) ? "int32" :
+        PyFloat_Check(first) ? "float64" : NULL
+    );
+
+    Py_DECREF(first);
+
+    if (!inferred_dtype) {
+        Py_DECREF(buffer_obj);
+        PyErr_SetString(PyExc_TypeError, "Unsupported element type");
+        return NULL;
+    }
+
+    PyObject* sys = PyImport_ImportModule("sys");
+    PyObject* sys_path = PyObject_GetAttrString(sys, "path");
+    Py_DECREF(sys);
+
+    Py_ssize_t original_len = PyList_Size(sys_path);
+    if (original_len == -1) {
+        Py_DECREF(sys_path);
+        return NULL;
+    }
+
+    PyObject* path = PyUnicode_FromString("pydatastructs/linear_data_structures/_backend/cpp/algorithms");
+    if (!path) {
+        Py_DECREF(sys_path);
+        return NULL;
+    }
+
+    int append_result = PyList_Append(sys_path, path);
+    Py_DECREF(path);
+    if (append_result != 0) {
+        Py_DECREF(sys_path);
+        return NULL;
+    }
+
+    PyObject* mod = PyImport_ImportModule("llvm_algorithms");
+
+    if (PyList_SetSlice(sys_path, original_len, original_len + 1, NULL) != 0) {
+        PyErr_Clear();
+    }
+    Py_DECREF(sys_path);
+
+    PyObject* fn = PyObject_GetAttrString(mod, "get_insertion_sort_ptr");
+    Py_DECREF(mod);
+
+    PyObject* arg = PyUnicode_FromString(inferred_dtype);
+    if (!arg) {
+        Py_DECREF(fn);
+        return NULL;
+    }
+
+    PyObject* addr_obj = PyObject_CallFunctionObjArgs(fn, arg, NULL);
+    Py_DECREF(fn);
+    Py_DECREF(arg);
+    if (!addr_obj) {
+        Py_DECREF(buffer_obj);
+        return NULL;
+    }
+
+    long long addr = PyLong_AsLongLong(addr_obj);
+    Py_DECREF(addr_obj);
+
+    if (PyErr_Occurred()) {
+        Py_DECREF(buffer_obj);
+        return NULL;
+    }
+
+    if (strcmp(inferred_dtype, "int32") == 0) {
+        typedef void (*fn_t)(int*, int);
+        fn_t insertion_sort_fn = (fn_t)(intptr_t)addr;
+        int* arr = (int*)malloc(sizeof(int) * arr_len);
+        for (Py_ssize_t i = 0; i < arr_len; i++) {
+            PyObject* item = PySequence_GetItem(buffer_obj, i);
+            arr[i] = (int)PyLong_AsLong(item);
+            Py_DECREF(item);
+        }
+        insertion_sort_fn(arr, (int)arr_len);
+        for (Py_ssize_t i = 0; i < arr_len; i++) {
+            PyObject* v = PyLong_FromLong(arr[i]);
+            PySequence_SetItem(buffer_obj, i, v);
+            Py_DECREF(v);
+        }
+        free(arr);
+    } else if (strcmp(inferred_dtype, "int64") == 0) {
+        typedef void (*fn_t)(long long*, int);
+        fn_t insertion_sort_fn = (fn_t)(intptr_t)addr;
+        long long* arr = (long long*)malloc(sizeof(long long) * arr_len);
+        for (Py_ssize_t i = 0; i < arr_len; i++) {
+            PyObject* item = PySequence_GetItem(buffer_obj, i);
+            arr[i] = PyLong_AsLongLong(item);
+            Py_DECREF(item);
+        }
+        insertion_sort_fn(arr, (int)arr_len);
+        for (Py_ssize_t i = 0; i < arr_len; i++) {
+            PyObject* v = PyLong_FromLongLong(arr[i]);
+            PySequence_SetItem(buffer_obj, i, v);
+            Py_DECREF(v);
+        }
+        free(arr);
+    } else if (strcmp(inferred_dtype, "float32") == 0) {
+        typedef void (*fn_t)(float*, int);
+        fn_t insertion_sort_fn = (fn_t)(intptr_t)addr;
+        float* arr = (float*)malloc(sizeof(float) * arr_len);
+        for (Py_ssize_t i = 0; i < arr_len; i++) {
+            PyObject* item = PySequence_GetItem(buffer_obj, i);
+            arr[i] = (float)PyFloat_AsDouble(item);
+            Py_DECREF(item);
+        }
+        insertion_sort_fn(arr, (int)arr_len);
+        for (Py_ssize_t i = 0; i < arr_len; i++) {
+            PyObject* v = PyFloat_FromDouble(arr[i]);
+            PySequence_SetItem(buffer_obj, i, v);
+            Py_DECREF(v);
+        }
+        free(arr);
+    } else if (strcmp(inferred_dtype, "float64") == 0) {
+        typedef void (*fn_t)(double*, int);
+        fn_t insertion_sort_fn = (fn_t)(intptr_t)addr;
+        double* arr = (double*)malloc(sizeof(double) * arr_len);
+        for (Py_ssize_t i = 0; i < arr_len; i++) {
+            PyObject* item = PySequence_GetItem(buffer_obj, i);
+            arr[i] = PyFloat_AsDouble(item);
+            Py_DECREF(item);
+        }
+        insertion_sort_fn(arr, (int)arr_len);
+        for (Py_ssize_t i = 0; i < arr_len; i++) {
+            PyObject* v = PyFloat_FromDouble(arr[i]);
+            PySequence_SetItem(buffer_obj, i, v);
+            Py_DECREF(v);
+        }
+        free(arr);
+    } else {
+        Py_DECREF(buffer_obj);
+        PyErr_SetString(PyExc_TypeError, "Unsupported dtype for insertion_sort_llvm");
+        return NULL;
+    }
+
+    if (is_dynamic && PyObject_HasAttrString(arr_obj, "_modify")) {
+        PyObject* modify_fn = PyObject_GetAttrString(arr_obj, "_modify");
+        if (modify_fn) {
+            PyObject_CallFunctionObjArgs(modify_fn, NULL);
+            Py_DECREF(modify_fn);
+        } else {
+            PyErr_Clear();
+        }
+    }
+
+    Py_DECREF(buffer_obj);
+    Py_INCREF(arr_obj);
+    return arr_obj;
+}
 
 #endif
diff --git a/pydatastructs/linear_data_structures/algorithms.py b/pydatastructs/linear_data_structures/algorithms.py
@@ -1513,6 +1513,8 @@ def insertion_sort(array, **kwargs):
     backend = kwargs.pop("backend", Backend.PYTHON)
     if backend == Backend.CPP:
         return _algorithms.insertion_sort(array, **kwargs)
+    if backend == Backend.LLVM:
+        return _algorithms.insertion_sort_llvm(array, **kwargs)
     start = kwargs.get('start', 0)
     end = kwargs.get('end', len(array) - 1)
     comp = kwargs.get('comp', lambda u, v: u <= v)
diff --git a/pydatastructs/linear_data_structures/tests/test_algorithms.py b/pydatastructs/linear_data_structures/tests/test_algorithms.py
@@ -130,6 +130,7 @@ def test_selection_sort():
 def test_insertion_sort():
     _test_common_sort(insertion_sort)
     _test_common_sort(insertion_sort, backend=Backend.CPP)
+    _test_common_sort(insertion_sort, backend=Backend.LLVM)
 
 def test_matrix_multiply_parallel():
     ODA = OneDimensionalArray
