Generic type support of multi dimensional Array

[ramakotareddy]

Hi @manuranga, As per yesterday's discussion in call, working multi dimensional arrays with other types (float, boolean and string types) without creating separate init and load functions. i have created init and load for multi dimensional arrays in Rust files like below.

Rust Functions for multi dimensional Array:

Init Function:

#[no_mangle]
pub extern "C" fn array_init_array_array(size: i32) -> *mut Vec<*mut Vec<*mut i32>> {
let size_t = if size > 0 { size } else { 8 };
let size_t = size_t as usize;
let initVec: Box<Vec<*mut Vec<*mut i32>>> = Box::new(Vec::with_capacity(size_t));
let vec_pointer = Box::into_raw(initVec);
return vec_pointer as *mut Vec<*mut Vec<*mut i32>>;
}

Load Function:

#[no_mangle]
pub extern "C" fn array_load_array_array(arr_ptr: *mut Vec<*mut Vec<*mut i32>>, index: i32) -> *mut Vec<*mut i32> {
let mut arr = unsafe { Box::from_raw(arr_ptr) };
let index_n = index as usize;
let len = index_n + 1;
if arr.len() < len {
arr.resize(len, 0 as *mut Vec<*mut i32>);
}
let mut return_val = arr[index_n];
if return_val.is_null() {
arr[index_n] = Box::into_raw(Box::new(Vec::with_capacity(len)));
}
return_val = arr[index_n];
mem::forget(arr);
return return_val;
}

multi dimensional test cases with string and int types:

public function main() {
string[][][][][] arr1 = [[], [],[],[],[]];
arr1[0][1][1][1][1] = "Hello";
arr1[1][2][2][2][2] = " World";
string a = arr1[0][1][1][1][1];
string b = arr1[1][2][2][2][2];
print_string(a);
print_string(b);
}

int[][][] arr1 = [[], [], []];
int[][][] arr2 = [[], [], []];
public function main() {
arr1 = [[], [], []];
arr1[0][1][1] = 1;
arr1[1][1][2] = 5;
arr1[3][3][3] = 10;
int index1 = 3;
arr2 = [[], [], []];
arr2[1][2][2] = 10;
arr2[3][3][3] = 50;
arr2[4][2][1] = 100;
int index2 = 4;
int a = arr1[0][1][1] + arr1[1][1][2] + arr1[index1][index1][index1];
int b = arr2[1][2][2] + arr2[3][3][3] + arr2[index2][2][1];
print_string("RESULT=");
printu32(a + b);
}

The above test cases are working with above Rust functions. Do we need to create separate init and load functions for other types(float, bool and string types) or is these Rust functions are enough?

@manuranga @ruvi-d and @KavinduZoysa Please give your suggestions.

[ruvi-d]

Couple of thoughts:

1. Looks like you are using pub extern "C" fn array_init_array_array(size: i32) -> *mut Vec<*mut Vec<*mut i32>> for string[][][][][] arr1's init. That means you are storing BString/c-string pointers in a vect<*mut i32>. This is obviously not type safe and will break when you do #218 (pass and store array members as value, not reference).
   • This is why I suggested to prioritize #218 before doing array of arrays
2. I think we need to see how the BIR representation is to give you any alternate suggestions

PS: please fix code snippet formatting

[ramakotareddy]

Hi @ruvi-d , i am passing values instead of references for int, float and boolean of array's in Rust side and i have changed in codegen side accordingly.

Please find the below Rust functions of int type with pass by value.

#[no_mangle]
pub extern "C" fn array_init_int(size: i32) -> *mut Vec

#[no_mangle]
pub extern "C" fn array_store_int(arr_ptr: *mut Vec, index: i32, ref_ptr: i32)

#[no_mangle]
pub extern "C" fn array_load_int(arr_ptr: *mut Vec, index: i32) -> i32

#[no_mangle]
pub extern "C" fn array_init_array_array(size: i32) -> *mut Vec<*mut Vec>

#[no_mangle]
pub extern "C" fn array_load_array_array(arr_ptr: *mut Vec<*mut Vec>, index: i32) -> *mut Vec

[ruvi-d]

We are going off topic here. Let's take it separately if you have problems with the pass by value implementation.

[ramakotareddy]

@ruvi-d, I am able to pass by value and printing correct values using above Rust functions of int, float and boolean types without any issues.
Just check the above Rust functions are correct or have any mistakes?

[ramakotareddy]

@ruvi-d, Please give your suggestions on the above.

[ruvi-d]

Looks ok with the limited info

[ruvi-d]

One more thing, in your code snippet:

int[][][] arr1 = [[], [], []];

You have only provided initialization for two levels of arrays.
I think you meant this:

int[][][] arr1 = [[[1,2,3],[4,5,6],[7,8,9]], [[10,11,12],[13,14,15],[16,17,18]], [[19,20,21],[22,23,24],[25,26,27]]];  #3x3x3

[ramakotareddy]

@ruvi-d, I will change the code in test cases like above code.
int[][][] arr1 = [[[],[],[]], [[],[],[]], [[],[][],[]]]; can we initialize like this also ? Please suggest.

[ruvi-d]

yes. that should initialize an empty array

[ramakotareddy]

@manuranga Please give your suggestions on "Do we need to create separate init and load functions for other types(float, bool and string types) or is these Rust functions are enough?"

[manuranga]

Hi Ram, Really sorry about not being able to attend to this due to JBallerina release work. I looked into this a little bit, and it looks like this needs a bit of research. As we can see from here https://users.rust-lang.org/t/how-to-implement-simple-n-dimensional-vector-in-rust/47015 a naive solution will not work. We could try to use a const-generic feature of rust but I guess it will be too complex.

I guess the easy approach is to define a BalArray structure which internally can have a tagged enum like behavior. But more experimentation is needed to figure out the exact structure.