/*
* Writes a term to a stream.
*/
size_t
write_term_to_stream(const int fd,const YAP_Term term) {
RESET_BUFFER();
printf("BUFFER_PTR=%p\n", BUFFER_PTR);
p2c_putt(term);
if (write(fd,(void*)BUFFER_PTR,BUFFER_LEN) < 0) { // write term
YAP_Error(0,0,"Prolog2Term: IO error in write.\n");
return -1;
}
return BUFFER_LEN;
}
/*
* Broadcasts a message from the process with rank "root" to
* all other processes of the group.
* Note: Collective communication means all processes within a communicator call the same routine.
* To be able to use a regular MPI_Recv to recv the messages, one should use mpi_bcast2
*
* mpi_bcast(+Root,+Data).
*/
static YAP_Bool
mpi_bcast(term_t YAP_ARG1,...) {
YAP_Term t1 = YAP_Deref(YAP_ARG1),
t2 = YAP_Deref(YAP_ARG2);
int root,val;
size_t len=0;
char *str;
int rank;
//The arguments should be bound
if(!YAP_IsIntTerm(t1)) {
return false;
}
MPI_CALL(MPI_Comm_rank(MPI_COMM_WORLD, &rank));
CONT_TIMER();
root = YAP_IntOfTerm(t1);
if (root == rank) {
str=term2string(NULL,&len,t2);
#ifdef DEBUG
write_msg(__FUNCTION__,__FILE__,__LINE__,"mpi_bcast(%s,%u, MPI_CHAR,%d)\n",str,len,root);
#endif
} else {
RESET_BUFFER();
str = BUFFER_PTR;
len = BLOCK_SIZE;
}
// send the data
val=(MPI_CALL(MPI_Bcast( str, len, MPI_CHAR, root, MPI_COMM_WORLD))==MPI_SUCCESS?true:false);
#ifdef MPISTATS
{
int size;
MPI_CALL(MPI_Comm_size(MPI_COMM_WORLD, &size));
MSG_SENT(len*size);
}
#endif
PAUSE_TIMER();
if (root != rank) {
YAP_Term out;
len=YAP_SizeOfExportedTerm(str);
// make sure we only fetch ARG3 after constructing the term
out = string2term(str,(size_t*)&len);
MSG_RECV(len);
if (!YAP_Unify(YAP_ARG2, out))
return false;
}
return(val);
}
/*
* Read a prolog term from a stream
* (the prolog term must have been writen by the write_term_to_stream)
*/
YAP_Term
read_term_from_stream(const int fd) {
size_t size;
RESET_BUFFER();
if (!read(fd,(void*)&size,sizeof(size_t))) { // read the size of the term
YAP_Error(0,0,"Prolog2Term: IO error in read.\n");
}
#ifdef DEBUG
write_msg(__FUNCTION__,__FILE__,__LINE__,"read_term_from_stream>>>>size:%d\n",size);
#endif
if ( size> BUFFER_SIZE)
expand_buffer(size-BUFFER_SIZE);
if (!read(fd,BUFFER_PTR,size)) {
YAP_Error(0,0,"Prolog2Term: IO error in read.\n");
}; // read term from stream
return YAP_ImportTerm( BUFFER_PTR);
}
/*
* Converts a term t into a string.
* The ascii representation of t is
* copied to ptr if it occupies less than size.
*/
char*
term2string(char *const ptr, size_t *size, const YAP_Term t) {
char *ret;
RESET_BUFFER();
do {
if (*size == 0) {
*size = BUFFER_LEN = YAP_ExportTerm( t, BUFFER_PTR, BUFFER_SIZE );// canonical
ret=BUFFER_PTR;
if (BUFFER_LEN == 0) {
expand_buffer(BLOCK_SIZE);
}
} else {
*size = YAP_ExportTerm( t, ptr, BUFFER_SIZE );// canonical
ret=ptr;
}
} while (*size <= 0);
return ret;
}
/*
* Implements a non-blocking receive operation.
* mpi_irecv(?Source,?Tag,-Handle).
*/
static YAP_Bool
mpi_irecv(term_t YAP_ARG1,...) {
YAP_Term t1 = YAP_Deref(YAP_ARG1),
t2 = YAP_Deref(YAP_ARG2),
t3 = YAP_Deref(YAP_ARG3);
int tag, orig;
MPI_Request *mpi_req=(MPI_Request*)malloc(sizeof(MPI_Request));
// The third argument (data) must be unbound
if(!YAP_IsVarTerm(t3)) {
//Yap_Error(INSTANTIATION_ERROR, t_data, "mpi_receive");
return false;
}
/* The first argument (Source) must be bound to an integer
(the rank of the source) or left unbound (i.e. any source
is OK) */
if (YAP_IsVarTerm(t1)) orig = MPI_ANY_SOURCE;
else if( !YAP_IsIntTerm(t1) ) return false;
else orig = YAP_IntOfTerm(t1);
/* The third argument must be bound to an integer (the tag)
or left unbound (i.e. any tag is OK) */
if (YAP_IsVarTerm(t2)) tag = MPI_ANY_TAG;
else if( !YAP_IsIntTerm(t2) ) return false;
else tag = YAP_IntOfTerm( t2 );
CONT_TIMER();
RESET_BUFFER();
if( MPI_CALL(MPI_Irecv( BUFFER_PTR, BLOCK_SIZE, MPI_CHAR, orig, tag,
MPI_COMM_WORLD, mpi_req )) != MPI_SUCCESS ) {
PAUSE_TIMER();
return false;
}
new_request(mpi_req,BUFFER_PTR);
DEL_BUFFER();
PAUSE_TIMER();
return YAP_Unify(t3,YAP_MkIntTerm(HANDLE2INT(mpi_req)));
}
int
dev_putdata(struct buffer *bp)
{
struct pty *pty = &Pty;
int ret;
int size;
int frombuf;
/* XXXX TSR_MEASURES */
while (bp->b_hold) {
size = min(bp->b_hold, pty->iosize);
if ((ret = write(P_mfd, bp->b_rem, size)) == -1) {
if (errno == EAGAIN) {
ret = 0;
}
else {
sysmessage(MSG_ERR,
"Can't write on master pty: %s\n",
strerror(errno));
}
# ifdef TSR_MEASURE
devnwrites++;
# endif
return (ret);
}
# ifdef TSR_MEASURE
devwrites++;
devwbytes += ret;
# endif
FORWARD_BUFFER(bp, ret);
}
if (bp->b_hold == 0) {
RESET_BUFFER(bp);
}
return (0);
}
int
tel_putdata(struct buffer *bp)
{
unsigned char c;
int ret;
int size;
int frombuf;
while (bp->b_hold) {
if (Nvt.servertype == SRV_SOCKET) {
size = min(bp->b_hold, Nvt.iosize);
COPY_FROM_BUFFER(bp, Comobuf, size);
if ((ret = sock_write(Comobuf, size)) != size) {
if (ret < 0) {
return (ret);
}
else {
frombuf = size - ret;
REWIND_BUFFER(bp, frombuf);
}
break;
}
}
else { /* OH OH -> Handling IAC */
frombuf = min(bp->b_hold, Nvt.iosize);
size = 0;
while (frombuf--) {
c = GET_BUFFER(bp);
if (c == IAC) {
if (size == Nvt.iosize - 1) {
/* avoid break IAC mapping */
REWIND_BUFFER(bp, 1);
frombuf++;
break;
}
Comobuf[size++] = IAC;
}
Comobuf[size++] = c;
if (size == Nvt.iosize) {
break;
}
}
/* the following used to be #if 1 in the linux tree and not included for HPUX */
#ifdef __linux__
frombuf = 0;
while (size > 0) {
if ((ret = sock_write(&Comobuf[frombuf], size)) == size) {
break;
}
if (Debug > 2) {
sysmessage(MSG_DEBUG, "Sock write: %d of %d\n", ret,
size);
}
if (ret < 0) {
return (ret);
}
frombuf += ret;
size -= ret;
}
#else
if ((ret = sock_write(Comobuf, size)) != size) {
if (Debug > 2) {
sysmessage(MSG_DEBUG, "Sock write: %d\n", ret);
}
if (ret < 0) {
return (ret);
}
else {
frombuf = 0;
while (size-- > ret) {
if ((c = Comobuf[size - 1])
== IAC) {
continue;
}
frombuf++;
}
}
if (Debug > 2) {
sysmessage(MSG_DEBUG, "Buffer rewind %d\n", frombuf);
}
REWIND_BUFFER(bp, frombuf);
break;
}
#endif
}
}
if (bp->b_hold == 0) {
RESET_BUFFER(bp);
}
return (0);
}
static int do_spi_io(struct spi_device* lp_dev, u8* lp_send_buffer, u8* lp_recv_buffer,
int buffer_size)
{
int ret_value;
struct spi_message msg;
struct spi_transfer xfer =
{
.len = buffer_size,
.tx_buf = (void*)lp_send_buffer,
.rx_buf = (void*)lp_recv_buffer,
.speed_hz = 1000000,
};
spi_message_init(&msg);
spi_message_add_tail(&xfer, &msg);
dev_info(&lp_dev->dev, "spi io: transfer size = %d\n", buffer_size);
ret_value = spi_sync(lp_dev, &msg);
if (IS_SUCCESS(ret_value))
{
dev_info(&lp_dev->dev, "spi io done.\n");
}
dev_info(&lp_dev->dev, "do_spi_io ret_value = %d\n", ret_value);
return ret_value;
}
int do_io_transaction(struct spi_device* lp_dev,
_IN_ struct spi_io_context* lp_io_context,
_IN_ u8* const lp_send_buffer, int send_buffer_size,
_OUT_ u8* lp_recv_buffer, int recv_buffer_size,
_OUT_ int* lp_recved_size )
{
int ret_value = ER_FAILED;
int total_trafster = 0;
int one_time_transfer = 0;
int total_receive_size = 0;
int remain_send_count = send_buffer_size;
int remain_recv_count = 0;
int is_recved_vaild_fh = 0;
struct buffer* lp_send_operator = NULL;
struct buffer* lp_recv_operator = NULL;
struct buffer dummy_send_buffer;
struct buffer dummy_recv_buffer;
struct buffer send_buffer;
struct buffer recv_buffer;
INIT_BUFFER(&dummy_send_buffer,
lp_io_context->send_dummy_buffer,
lp_io_context->send_dummy_buffer_size);
INIT_BUFFER(&dummy_recv_buffer,
lp_io_context->recv_dummy_buffer,
lp_io_context->recv_dummy_buffer_size);
INIT_BUFFER(&send_buffer, lp_send_buffer, send_buffer_size);
INIT_BUFFER(&recv_buffer, lp_recv_buffer, recv_buffer_size);
/*need some check here, but still in think.*/
total_trafster = send_buffer_size;
while(total_trafster > 0)
{
int send_buffer_is_dummy;
int recv_buffer_is_dummy;
/*
Step1. try calc out transfer bye count
*/
if (0 != BUFFER_REMAIN_LENGTH(send_buffer))
{
lp_send_operator = &send_buffer;
send_buffer_is_dummy = FALSE;
}
else
{
lp_send_operator = &dummy_send_buffer;
send_buffer_is_dummy = TRUE;
}
if (0 != remain_recv_count
&& is_recved_vaild_fh)
{
lp_recv_operator = &recv_buffer;
recv_buffer_is_dummy = FALSE;
}
else
{
lp_recv_operator = &dummy_recv_buffer;
recv_buffer_is_dummy = TRUE;
}
if (is_recved_vaild_fh)
{
RESET_BUFFER(&dummy_send_buffer);
RESET_BUFFER(&dummy_recv_buffer);
if (send_buffer_is_dummy && recv_buffer_is_dummy)
{
one_time_transfer = 0;
}
else
{
one_time_transfer = MIN(BUFFER_REMAIN_LENGTH(*lp_send_operator),
BUFFER_REMAIN_LENGTH(*lp_recv_operator));
}
}
else
{
/*
can't reset dummy recv buffer because it contain last time received
splited data
*/
one_time_transfer = MIN(BUFFER_REMAIN_LENGTH(*lp_send_operator),
BUFFER_REMAIN_LENGTH(dummy_recv_buffer));
}
if (0 == one_time_transfer)
{
/*caller's receive buffer is not enough case.*/
if ( 0 != remain_recv_count)
{
ret_value = ER_NO_ENOUGH_RECV_BUFFER;
}
break;
}
/*
Step 2. Prepare and do transfer
*/
dev_info(&lp_dev->dev, "before do_spi_io\n");
ret_value = do_spi_io(lp_dev,
BUFFER_PTR(*lp_send_operator),
BUFFER_PTR(*lp_recv_operator),
one_time_transfer);
if (IS_FAILED(ret_value))
{
dev_err(&lp_dev->dev, "do_spi_io() failed! \n");
break;
}
dev_info(&lp_dev->dev, "after do_spi_io\n");
lp_send_operator->index += one_time_transfer;
lp_recv_operator->index += one_time_transfer;
remain_send_count = MAX(0, remain_send_count - one_time_transfer);
remain_recv_count = MAX(0, remain_recv_count - one_time_transfer);
total_trafster -= one_time_transfer;
/*
Step 3. check if we received valid frame header
*/
if (!is_recved_vaild_fh)
{
int total_payload_size;
int contained_payload_size;
int fh_start_index;
int is_valid_fh;
is_valid_fh = verify_frame_head_and_get_payload_size(lp_recv_operator->lp_ptr,
BUFFER_USED_LENGTH(*lp_recv_operator),
&total_payload_size,
&contained_payload_size,
&fh_start_index);
if (IS_SUCCESS(is_valid_fh))
{
int copy_size = contained_payload_size + SIZE_OF_FRAME_HEAD;
int need_recv_buffer_size = total_payload_size + SIZE_OF_FRAME_HEAD;
/*received new frame head!*/
remain_recv_count = total_payload_size - contained_payload_size;
/*received frame head, so we update total transfer count here*/
total_trafster = MAX(remain_recv_count, remain_send_count);
/*
printf("[packege check]: total payload = %d, contained = %d, fh_start = %d\n",
total_payload_size,
contained_payload_size,
fh_start_index);
*/
/*copy all valid data to actual receive buffer head*/
if (need_recv_buffer_size > BUFFER_REMAIN_LENGTH(recv_buffer))
{
ret_value = ER_NO_ENOUGH_RECV_BUFFER;
break;
}
/*do not reset buffer, because we now support
received mulit-frame in one io cycle.
*/
//RESET_BUFFER(&recv_buffer);
memcpy(BUFFER_PTR(recv_buffer),
lp_recv_operator->lp_ptr + fh_start_index,
copy_size);
/*
save total received size here to support receive mulit-frame
*/
total_receive_size += need_recv_buffer_size;
recv_buffer.index += copy_size;
recv_buffer.length = total_receive_size;
// pr_err("dump: index = %d, length = %d\n",
// recv_buffer.index, recv_buffer.length);
is_recved_vaild_fh = TRUE;
}
else
{
int is_recved_hf_prefix = ER_FAILED;
remain_recv_count = 0;
//copy SIZEOF_FRAME_HEAD bytes from tail to head
memcpy(dummy_recv_buffer.lp_ptr,
BUFFER_PTR_FROM_USED_TAIL(*lp_recv_operator, SIZE_OF_FRAME_HEAD),
SIZE_OF_FRAME_HEAD);
dummy_recv_buffer.index = SIZE_OF_FRAME_HEAD;
/*check if the last SIZE_OF_FRAME_HEAD bytes contained frame head prefix,
we will read more data if it contained, to resovle slice case
*/
is_recved_hf_prefix = verify_frame_head_prefix(BUFFER_PTR_FROM_USED_TAIL(*lp_recv_operator, SIZE_OF_FRAME_HEAD),
SIZE_OF_FRAME_HEAD);
/*
check if the received data included frame head prefix 0x53
*/
if (IS_SUCCESS(is_recved_hf_prefix))
{
total_trafster += BUFFER_REMAIN_LENGTH(dummy_recv_buffer);
/*
printf("set total_transfer = %d\n", total_trafster);
*/
}
is_recved_vaild_fh = FALSE;
}
}
else
{
/*
if we already received one frame, but still has some data need
send, we need change is_recved_vaild_fh = FALSE to prepare receive
the next frame
*/
#if 1
if (remain_send_count > 0
&& 0 == remain_recv_count)
{
is_recved_vaild_fh = FALSE;
RESET_BUFFER(&dummy_recv_buffer);
//pr_err("psh: note: try receive mulit-frame.\n");
}
#endif
}
}
#if 1
if (IS_FAILED(ret_value))
{
/*
dump recvied buffer
*/
dump_buffer(lp_recv_operator->lp_ptr, BUFFER_USED_LENGTH(*lp_recv_operator));
}
else
{
//dump_buffer(recv_buffer.lp_ptr, BUFFER_USED_LENGTH(recv_buffer));
}
#endif
lp_recved_size ? *lp_recved_size = BUFFER_USED_LENGTH(recv_buffer) : 0;
return ret_value;
}