Skip to content

Commit

Permalink
Merge pull request lcompilers#1382 from czgdp1807/bindc_struct_arr
Browse files Browse the repository at this point in the history 
Support data only array members for ``BindC`` structs
  • Loading branch information
@czgdp1807
czgdp1807 committed Dec 26, 2022
2 parents d916a2b + 245ce9c commit 0120e25
Show file tree
Hide file tree
Showing 5 changed files with 216 additions and 94 deletions.
77 changes: 73 additions & 4 deletions integration_tests/structs_14.py
View file
Original file line number Diff line number Diff line change
@@ -1,32 +1,101 @@
from ltypes import i8, dataclass, i32, ccallable
from numpy import empty, int8
from ltypes import i8, dataclass, i32, f32, c32, f64, i16, i64, c64, ccallable
from numpy import empty, int8, int16, int32, int64, float32, complex64, complex128, float64
from copy import deepcopy

@dataclass
class buffer_struct:
buffer: i8[32]
buffer1: i32[32]
buffer2: f32[32]
buffer3: c32[32]
buffer4: f64[32]
buffer5: i16[32]
buffer6: i64[32]
buffer7: c64[32]

@ccallable
@dataclass
class buffer_struct_clink:
buffer: i8[32]
buffer1: i32[32]
buffer2: f32[32]
buffer3: c32[32]
buffer4: f64[32]
buffer5: i16[32]
buffer6: i64[32]
buffer7: c64[32]

def f():
i: i32
buffer_var: i8[32] = empty(32, dtype=int8)
buffer_: buffer_struct = buffer_struct(deepcopy(buffer_var))
buffer_clink_: buffer_struct_clink = buffer_struct_clink(deepcopy(buffer_var))
buffer1_var: i32[32] = empty(32, dtype=int32)
buffer2_var: f32[32] = empty(32, dtype=float32)
buffer3_var: c32[32] = empty(32, dtype=complex64)
buffer4_var: f64[32] = empty(32, dtype=float64)
buffer5_var: i16[32] = empty(32, dtype=int16)
buffer6_var: i64[32] = empty(32, dtype=int64)
buffer7_var: c64[32] = empty(32, dtype=complex128)
buffer_: buffer_struct = buffer_struct(deepcopy(buffer_var), deepcopy(buffer1_var),
deepcopy(buffer2_var), deepcopy(buffer3_var),
deepcopy(buffer4_var), deepcopy(buffer5_var),
deepcopy(buffer6_var), deepcopy(buffer7_var))
buffer_clink_: buffer_struct_clink = buffer_struct_clink(deepcopy(buffer_var), deepcopy(buffer1_var),
deepcopy(buffer2_var), deepcopy(buffer3_var),
deepcopy(buffer4_var), deepcopy(buffer5_var),
deepcopy(buffer6_var), deepcopy(buffer7_var))
print(buffer_.buffer[15])
print(buffer_.buffer1[15])
print(buffer_.buffer2[15])
print(buffer_.buffer3[15])
print(buffer_.buffer4[15])
print(buffer_.buffer5[15])
print(buffer_.buffer6[15])
print(buffer_.buffer7[15])
print(buffer_clink_.buffer[15])
print(buffer_clink_.buffer1[15])
print(buffer_clink_.buffer2[15])
print(buffer_clink_.buffer3[15])
print(buffer_clink_.buffer4[15])
print(buffer_clink_.buffer5[15])
print(buffer_clink_.buffer6[15])
print(buffer_clink_.buffer7[15])

for i in range(32):
buffer_.buffer[i] = i8(i + 1)
buffer_clink_.buffer[i] = i8(i + 2)
buffer_.buffer1[i] = i32(i + 3)
buffer_clink_.buffer1[i] = i32(i + 4)
buffer_.buffer2[i] = f32(i + 5)
buffer_clink_.buffer2[i] = f32(i + 6)
buffer_.buffer3[i] = c32(i + 7)
buffer_clink_.buffer3[i] = c32(i + 8)
buffer_.buffer4[i] = f64(i + 9)
buffer_clink_.buffer4[i] = f64(i + 10)
buffer_.buffer5[i] = i16(i + 11)
buffer_clink_.buffer5[i] = i16(i + 12)
buffer_.buffer6[i] = i64(i + 13)
buffer_clink_.buffer6[i] = i64(i + 14)
buffer_.buffer7[i] = c64(i + 15)
buffer_clink_.buffer7[i] = c64(i + 16)

for i in range(32):
print(i, buffer_.buffer[i], buffer_clink_.buffer[i])
print(i, buffer_clink_.buffer1[i], buffer_.buffer1[i])
print(i, buffer_clink_.buffer2[i], buffer_.buffer2[i])
print(i, buffer_clink_.buffer3[i], buffer_.buffer3[i])
print(i, buffer_clink_.buffer4[i], buffer_.buffer4[i])
print(i, buffer_clink_.buffer5[i], buffer_.buffer5[i])
print(i, buffer_clink_.buffer6[i], buffer_.buffer6[i])
print(i, buffer_clink_.buffer7[i], buffer_.buffer7[i])
assert buffer_.buffer[i] == i8(i + 1)
assert buffer_clink_.buffer[i] == i8(i + 2)
assert buffer_clink_.buffer[i] - buffer_.buffer[i] == i8(1)
assert buffer_clink_.buffer1[i] - buffer_.buffer1[i] == i32(1)
assert buffer_clink_.buffer2[i] - buffer_.buffer2[i] == f32(1)
assert buffer_clink_.buffer3[i] - buffer_.buffer3[i] == c32(1)
assert buffer_clink_.buffer4[i] - buffer_.buffer4[i] == f64(1)
assert buffer_clink_.buffer5[i] - buffer_.buffer5[i] == i16(1)
assert buffer_clink_.buffer6[i] - buffer_.buffer6[i] == i64(1)
assert buffer_clink_.buffer7[i] - buffer_.buffer7[i] == c64(1)

f()
24 changes: 24 additions & 0 deletions src/libasr/asr_utils.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -163,6 +163,12 @@ static inline ASR::abiType expr_abi(ASR::expr_t* e) {
case ASR::exprType::StructInstanceMember: {
return ASRUtils::symbol_abi(ASR::down_cast<ASR::StructInstanceMember_t>(e)->m_m);
}
case ASR::exprType::ArrayReshape: {
return ASRUtils::expr_abi(ASR::down_cast<ASR::ArrayReshape_t>(e)->m_array);
}
case ASR::exprType::GetPointer: {
return ASRUtils::expr_abi(ASR::down_cast<ASR::GetPointer_t>(e)->m_arg);
}
default:
throw LCompilersException("Cannot extract the ABI of " +
std::to_string(e->type) + " expression.");
Expand Down Expand Up @@ -1409,13 +1415,31 @@ static inline bool is_fixed_size_array(ASR::dimension_t* m_dims, size_t n_dims)
}
for( size_t i = 0; i < n_dims; i++ ) {
int64_t dim_size = -1;
if( m_dims[i].m_length == nullptr ) {
return false;
}
if( !ASRUtils::extract_value(ASRUtils::expr_value(m_dims[i].m_length), dim_size) ) {
return false;
}
}
return true;
}

static inline int64_t get_fixed_size_of_array(ASR::dimension_t* m_dims, size_t n_dims) {
if( n_dims == 0 ) {
return 0;
}
int64_t array_size = 1;
for( size_t i = 0; i < n_dims; i++ ) {
int64_t dim_size = -1;
if( !ASRUtils::extract_value(ASRUtils::expr_value(m_dims[i].m_length), dim_size) ) {
return -1;
}
array_size *= dim_size;
}
return array_size;
}

inline int extract_n_dims_from_ttype(ASR::ttype_t *x) {
ASR::dimension_t* m_dims_temp = nullptr;
return extract_dimensions_from_ttype(x, m_dims_temp);
Expand Down
82 changes: 52 additions & 30 deletions src/libasr/codegen/asr_to_c.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -147,11 +147,15 @@ class ASRToCVisitor : public BaseCCPPVisitor<ASRToCVisitor>
ASR::Variable_t* mem_var = ASR::down_cast<ASR::Variable_t>(itr.second);
std::string mem_var_name = current_scope->get_unique_name(itr.first + std::to_string(counter));
counter += 1;
ASR::dimension_t* m_dims = nullptr;
size_t n_dims = ASRUtils::extract_dimensions_from_ttype(mem_type, m_dims);
sub += indent + convert_variable_decl(*mem_var, true, true, true, true, mem_var_name) + ";\n";
if( mem_var->m_abi == ASR::abiType::BindC &&
ASR::is_a<ASR::Integer_t>(*mem_var->m_type) &&
ASRUtils::extract_kind_from_ttype_t(mem_var->m_type) == 1 ) {
sub += indent + "strcpy(" + name + "->" + itr.first + ", " + mem_var_name + ");\n";
ASRUtils::is_fixed_size_array(m_dims, n_dims) ) {
int64_t fixed_size_array = ASRUtils::get_fixed_size_of_array(m_dims, n_dims);
sub += indent + "memcpy(" + name + "->" + itr.first + ", " + mem_var_name + ", " +
std::to_string(fixed_size_array) + "*sizeof(" +
CUtils::get_c_type_from_ttype_t(mem_type) + "));\n";
} else {
sub += indent + name + "->" + itr.first + " = " + mem_var_name + ";\n";
}
Expand Down Expand Up @@ -245,11 +249,11 @@ class ASRToCVisitor : public BaseCCPPVisitor<ASRToCVisitor>
if( is_array ) {
bool is_fixed_size = true;
dims = convert_dims_c(t->n_dims, t->m_dims, v_m_type, is_fixed_size, true);
if( t->m_kind == 1 && v.m_abi == ASR::abiType::BindC && is_fixed_size ) {
if( v.m_abi == ASR::abiType::BindC && is_fixed_size ) {
if( !force_declare ) {
force_declare_name = std::string(v.m_name);
}
sub = "char " + force_declare_name + dims;
sub = type_name + " " + force_declare_name + dims;
} else {
std::string encoded_type_name = "i" + std::to_string(t->m_kind * 8);
bool is_struct_type_member = ASR::is_a<ASR::StructType_t>(
Expand Down Expand Up @@ -277,19 +281,26 @@ class ASRToCVisitor : public BaseCCPPVisitor<ASRToCVisitor>
if( is_array ) {
bool is_fixed_size = true;
dims = convert_dims_c(t->n_dims, t->m_dims, v_m_type, is_fixed_size, true);
std::string encoded_type_name = "r" + std::to_string(t->m_kind * 8);
bool is_struct_type_member = ASR::is_a<ASR::StructType_t>(
*ASR::down_cast<ASR::symbol_t>(v.m_parent_symtab->asr_owner));
if( !force_declare ) {
force_declare_name = std::string(v.m_name);
if( v.m_abi == ASR::abiType::BindC && is_fixed_size ) {
if( !force_declare ) {
force_declare_name = std::string(v.m_name);
}
sub = type_name + " " + force_declare_name + dims;
} else {
std::string encoded_type_name = "r" + std::to_string(t->m_kind * 8);
bool is_struct_type_member = ASR::is_a<ASR::StructType_t>(
*ASR::down_cast<ASR::symbol_t>(v.m_parent_symtab->asr_owner));
if( !force_declare ) {
force_declare_name = std::string(v.m_name);
}
generate_array_decl(sub, force_declare_name, type_name, dims,
encoded_type_name, t->m_dims, t->n_dims,
use_ref, dummy,
(v.m_intent != ASRUtils::intent_in &&
v.m_intent != ASRUtils::intent_inout &&
v.m_intent != ASRUtils::intent_out &&
!is_struct_type_member) || force_declare, is_fixed_size);
}
generate_array_decl(sub, force_declare_name, type_name, dims,
encoded_type_name, t->m_dims, t->n_dims,
use_ref, dummy,
(v.m_intent != ASRUtils::intent_in &&
v.m_intent != ASRUtils::intent_inout &&
v.m_intent != ASRUtils::intent_out &&
!is_struct_type_member) || force_declare, is_fixed_size);
} else {
bool is_fixed_size = true;
dims = convert_dims_c(t->n_dims, t->m_dims, v_m_type, is_fixed_size);
Expand All @@ -303,13 +314,26 @@ class ASRToCVisitor : public BaseCCPPVisitor<ASRToCVisitor>
if( is_array ) {
bool is_fixed_size = true;
dims = convert_dims_c(t->n_dims, t->m_dims, v_m_type, is_fixed_size, true);
std::string encoded_type_name = "c" + std::to_string(t->m_kind * 8);
generate_array_decl(sub, std::string(v.m_name), type_name, dims,
encoded_type_name, t->m_dims, t->n_dims,
use_ref, dummy,
v.m_intent != ASRUtils::intent_in &&
v.m_intent != ASRUtils::intent_inout,
is_fixed_size);
if( v.m_abi == ASR::abiType::BindC && is_fixed_size ) {
if( !force_declare ) {
force_declare_name = std::string(v.m_name);
}
sub = type_name + " " + force_declare_name + dims;
} else {
std::string encoded_type_name = "c" + std::to_string(t->m_kind * 8);
bool is_struct_type_member = ASR::is_a<ASR::StructType_t>(
*ASR::down_cast<ASR::symbol_t>(v.m_parent_symtab->asr_owner));
if( !force_declare ) {
force_declare_name = std::string(v.m_name);
}
generate_array_decl(sub, force_declare_name, type_name, dims,
encoded_type_name, t->m_dims, t->n_dims,
use_ref, dummy,
(v.m_intent != ASRUtils::intent_in &&
v.m_intent != ASRUtils::intent_inout &&
v.m_intent != ASRUtils::intent_out &&
!is_struct_type_member) || force_declare, is_fixed_size);
}
} else {
bool is_fixed_size = true;
dims = convert_dims_c(t->n_dims, t->m_dims, v_m_type, is_fixed_size);
Expand Down Expand Up @@ -1078,11 +1102,9 @@ R"(
ASR::ttype_t* x_mv_type = ASRUtils::expr_type(x.m_v);
ASR::dimension_t* m_dims;
int n_dims = ASRUtils::extract_dimensions_from_ttype(x_mv_type, m_dims);
bool is_i8_array = (ASR::is_a<ASR::Integer_t>(*x_mv_type) &&
ASRUtils::extract_kind_from_ttype_t(x_mv_type) == 1 &&
ASRUtils::is_fixed_size_array(m_dims, n_dims) &&
ASRUtils::expr_abi(x.m_v) == ASR::abiType::BindC);
if( is_i8_array ) {
bool is_data_only_array = (ASRUtils::is_fixed_size_array(m_dims, n_dims) &&
ASRUtils::expr_abi(x.m_v) == ASR::abiType::BindC);
if( is_data_only_array ) {
out += "[";
} else {
out += "->data[";
Expand All @@ -1096,7 +1118,7 @@ R"(
src = "/* FIXME right index */";
}

if( is_i8_array ) {
if( is_data_only_array ) {
current_index += src;
for( size_t j = i + 1; j < x.n_args; j++ ) {
int64_t dim_size;
Expand Down
51 changes: 27 additions & 24 deletions src/libasr/codegen/asr_to_c_cpp.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -728,34 +728,37 @@ R"(#include <stdio.h>
value + ") + 1 ) * sizeof(char));\n";
}
if( ASRUtils::is_array(m_target_type) && ASRUtils::is_array(m_value_type) ) {
bool is_target_i8_array = (ASR::is_a<ASR::Integer_t>(*m_target_type) &&
ASRUtils::extract_kind_from_ttype_t(m_target_type) == 1 &&
ASRUtils::expr_abi(x.m_target) == ASR::abiType::BindC);
bool is_value_i8_array = (ASR::is_a<ASR::Integer_t>(*m_value_type) &&
ASRUtils::extract_kind_from_ttype_t(m_value_type) == 1 &&
ASRUtils::expr_abi(x.m_value) == ASR::abiType::BindC);
bool is_target_fixed_size = false, is_value_fixed_size = false;
if( is_target_i8_array ) {
ASR::Integer_t* target_integer_t = ASR::down_cast<ASR::Integer_t>(m_target_type);
if( ASRUtils::is_fixed_size_array(target_integer_t->m_dims, target_integer_t->n_dims) ) {
is_target_fixed_size = true;
ASR::dimension_t* m_target_dims = nullptr;
size_t n_target_dims = ASRUtils::extract_dimensions_from_ttype(m_target_type, m_target_dims);
ASR::dimension_t* m_value_dims = nullptr;
size_t n_value_dims = ASRUtils::extract_dimensions_from_ttype(m_value_type, m_value_dims);
bool is_target_data_only_array = (ASRUtils::expr_abi(x.m_target) == ASR::abiType::BindC &&
ASRUtils::is_fixed_size_array(m_target_dims, n_target_dims));
bool is_value_data_only_array = (ASRUtils::expr_abi(x.m_value) == ASR::abiType::BindC &&
ASRUtils::is_fixed_size_array(m_value_dims, n_value_dims));
if( is_target_data_only_array || is_value_data_only_array ) {
int64_t target_size = -1, value_size = -1;
if( !is_target_data_only_array ) {
target = target + "->data";
} else {
target_size = ASRUtils::get_fixed_size_of_array(m_target_dims, n_target_dims);
}
}
if( is_value_i8_array ) {
ASR::Integer_t* value_integer_t = ASR::down_cast<ASR::Integer_t>(m_value_type);
if( ASRUtils::is_fixed_size_array(value_integer_t->m_dims, value_integer_t->n_dims) ) {
is_value_fixed_size = true;
if( !is_value_data_only_array ) {
value = value + "->data";
} else {
value_size = ASRUtils::get_fixed_size_of_array(m_value_dims, n_value_dims);
}
}
if( (is_target_i8_array && is_target_fixed_size) ||
(is_value_i8_array && is_value_fixed_size) ) {
if( !(is_target_i8_array && is_target_fixed_size) ) {
target = "(char*) " + target + "->data";
if( target_size != -1 && value_size != -1 ) {
LFORTRAN_ASSERT(target_size == value_size);
}
if( !(is_value_i8_array && is_value_fixed_size) ) {
value = "(char*) " + value + "->data";
int64_t array_size = -1;
if( target_size != -1 ) {
array_size = target_size;
} else {
array_size = value_size;
}
src += indent + "strcpy(" + target + ", " + value + ");\n";
src += indent + "memcpy(" + target + ", " + value + ", " + std::to_string(array_size) + "*sizeof(" +
CUtils::get_c_type_from_ttype_t(m_target_type) + "));\n";
} else {
src += alloc + indent + c_ds_api->get_deepcopy(m_target_type, value, target) + "\n";
}
Expand Down
Loading

0 comments on commit 0120e25

Please sign in to comment.