int main (int argc, char** argv)
{
int ps = 1;
pthread_t pt[ps];
int size = 1*1024*1024/ps;
int i,j;
double ss, ee;
ss = get_dtime();
for (j = 0; j < 10; j++) {
size = size << 1;
for (i = 0; i < ps; i++) {
pthread_create(&pt[i], NULL, memlock, &size);
pthread_join(pt[i], NULL);
}
}
for (i = 0; i < ps; i++) {
pthread_join(pt[i], NULL);
}
ee = get_dtime();
fprintf(stderr, "Total size: %d, Time: %f\n", ps* (size/(1024*1024)), ee - ss);
}
void output_data(FILE *fp, int n, REAL tim, struct Energy *energies, struct Step *step)
{
step->tf = get_dtime();
fprintf(stderr, "Time: %9.3f\n", tim);
fprintf(fp, "Time: %9.3f\n", tim);
fprintf(fp, "---Energy----------------------------------------------------------------------\n");
fprintf(fp, "tot: %.8f ", energies->e);
fprintf(fp, "w: %.8f k: %.8f ", energies->ew, energies->ek);
fprintf(fp, "de: %+.3e de/|e|: %+.3e\n", energies->e - energies->ei, (energies->e - energies->ei) / (- energies->ei));
fprintf(fp, "---Time------------------------------------------------------------------------\n");
fprintf(fp, "tcalc: %.2e", step->tf - step->tb);
fprintf(fp, " %.2e Gflops", (REAL)step->step * (REAL)n * OPERATION / (step->tf - step->tb) * 1e-9);
#if 0
fprintf(fp, " niave: %.2e\n", (REAL)step->step / (REAL)step->blck);
#else
fprintf(fp, " niave: %.2e", (REAL)step->step / (REAL)step->blck);
fprintf(fp, " %e\n", (REAL)step->step);
#endif
fprintf(fp, "\n");
fflush(fp);
step->tb = get_dtime();
step->step = 0;
step->blck = 0;
return;
}
int main( int argc, char** argv) {
printf("start emps.\n");
RdDat();
AlcBkt();
SetPara();
double timer_sta = get_dtime();
ClcEMPS();
double timer_end = get_dtime();
printf("Total : %13.6lf sec\n",timer_end -timer_sta);
free(Acc);
free(Pos);
free(Vel);
free(Prs);
free(pav);
free(Typ);
free(bfst);
free(blst);
free(nxt);
printf("end emps.\n");
return 0;
}
int x_wait_for_last_refresh(double _w)
{
if (_w<0.0)
{
// on est trop lent : ca a pris plus d'une 1/60ieme de seconde pour construire la frame
return 0 ;
}
#ifdef DRIVER_IOS
extern int x_frame_rate;
if (x_frame_rate==60 && g_video_offscreen_has_been_modified && !x_vbl_count)
#else
if (g_video_offscreen_has_been_modified && !x_vbl_count)
#endif
{
while(!x_vbl_count && !r_sim65816.should_emulator_terminate()) micro_sleep(0.01);
x_vbl_count--;
}
else
{
if(_w>0.0)
{
double s = get_dtime();
if (_w>0.01)
micro_sleep(_w);
// sur windows le micro_sleep est lÈgËrement en retard!
while( get_dtime() < s+_w);
}
}
return 0;
}
int RDMA_transfer(char* src, char* dst, int buf_size, int count, struct RDMA_communicator *comm)
{
int i;
int fd;
int read_size;
int tag;
int ctl_msg_size;
struct file_buffer *fbufs;
int fbuf_index = 0;
int *flags;
char ctl_msg[1536];
double e,s;
fbufs = (struct file_buffer *)malloc(sizeof(struct file_buffer) * count);
flags = (int *)malloc(sizeof(int) * count);
for (i = 0; i < count; i++) {
fbufs[i % count].buf = (char *)malloc(buf_size);
flags[i % count] = 1;
}
/*send init*/
tag=get_tag();
sprintf(ctl_msg, "%d\t%s", tag, dst);
//printf(ctl_msg);
ctl_msg_size = strlen(ctl_msg);
RDMA_Sendr(ctl_msg, ctl_msg_size, TRANSFER_INIT, comm);
/*---------*/
/*send file*/
fd = open(src, O_RDONLY);
// printf("read fbuf_index=%d\n", fbuf_index);
read_size = buf_read(fd, fbufs[fbuf_index].buf, buf_size);
do {
// printf("sent fbuf_index=%d\n", fbuf_index);
RDMA_Isendr(fbufs[fbuf_index].buf, read_size, tag, &flags[fbuf_index], comm);
//flags[fbuf_index] = 1;
// printf("... sent done\n");
// printf("read fbuf_index=%d\n", fbuf_index);
s = get_dtime();
read_size = buf_read(fd, fbufs[(fbuf_index + 1) % count].buf, buf_size);
e = get_dtime();
// printf("ACT lib: read time = %fsecs, read size = %d MB, throughput = %f MB/s\n", e - s, read_size/1000000, read_size/(e - s)/1000000.0);
RDMA_Wait (&flags[fbuf_index]);
fbuf_index = (fbuf_index + 1) % count;
} while (read_size > 0);
/*---------*/
/*send fin*/
sprintf(ctl_msg, "%d\t%s", tag, dst);
ctl_msg_size = strlen(ctl_msg);
RDMA_Sendr(ctl_msg, ctl_msg_size, TRANSFER_FIN, comm);
/*---------*/
return 0;
}
int main (int argc, char *argv[])
{
int fd;
int i;
void *memfile;
struct stat statbuf;
double d0, d1;
int count;
printf("Page size:%d\n", getpagesize());
if ((fd = open(argv[1],O_RDONLY)) < 0){
printf("can't open\n");
}
if (fstat(fd,&statbuf) < 0){
printf("fstat error\n");
}
printf("mmap...");
memfile=mmap(0,statbuf.st_size,PROT_READ,MAP_SHARED,fd,0);
printf("done\n");
printf("mlock...");
mlock(memfile, statbuf.st_size);
printf("done\n");
printf("search1 ...");
d0 = get_dtime();
for (i=0; i<statbuf.st_size; i++){
char *cs = memfile;
char c = cs[i];
if (c=='a') {
count++;
}
}
d1 = get_dtime();
printf("done:%f (%d)\n", d1 - d0, count);
count=0;
printf("search2 ...");
d0 = get_dtime();
for (i=0; i<statbuf.st_size; i++){
char *cs = memfile;
char c = cs[i];
if (c=='a') {
count++;
}
}
d1 = get_dtime();
printf("done:%f (%d)\n", d1 - d0, count);
}
int main(){
double d0, d1;
d0 = get_dtime();
int i;
for(i=0; i<100; i++){
printf("t\n");
}
d1 = get_dtime();
printf("elapsed: %f", d1 - d0);
printf("hello\n");
return 0;
}
int nbcr_checkpoint(nbcr_comm *comm, unsigned long gen)
{
void* ckpt;
int checkpoint = 0;
double ts;
comm->perfc->gen = gen;
ts = get_dtime();
comm->perfc->tp = ts - comm->perfc->ts;
comm->perfc->ts = ts;
if (comm->on_ckpt) {
int status;
status = RDMA_Trywait(&(comm->req));
if (status != 0) {
checkpoint = 2;
fprintf(stderr, "Checkpoint start\n");
}
checkpoint = 0;
//fprintf(stderr, "Checkpoint still is on going\n");
} else {
checkpoint = 1;
fprintf(stderr, "First checkpoint start\n");
}
if (checkpoint > 0) {
comm->ckpt_info->gen = gen;
//memcpy(comm->ckpt, comm->data, comm->ckpt_info->size);
RDMA_Isend(comm->ckpt_info, sizeof(nbcr_perfc) + sizeof(nbcr_ckpt_info) + comm->ckpt_info->size, NULL, -1, NBCR_CKPT_TAG, &(comm->comm), &(comm->req));
comm->on_ckpt = 1;
}
return checkpoint;
}
int main(int argc, char** argv){
FILE *fp;
char str[PSIZE];
double d0, d1;
int i;
int count;
if ((fp = fopen(argv[1],"r")) < 0) {
printf("can't open file");
return -1;
}
printf("search1 ...");
d0 = get_dtime();
while((fgets(str,PSIZE,fp)) != NULL) {
printf("%s\n",str);
for (i=0; i<PSIZE; i++){
if (str[i]=='a') {
printf("a");
count++;
}
}
}
d1 = get_dtime();
printf("done: %f (%d)\n",d1 - d0, count);
count=0;
rewind(fp);
printf("search2 ...");
d0 = get_dtime();
while((fgets(str,PSIZE,fp)) != NULL) {
for (i=0; i<PSIZE; i++){
if (str[i]=='a') {
count++;
}
}
}
d1 = get_dtime();
printf("done: %f (%d)\n",d1 - d0, count);
fclose(fp);
return 0;
}
void __pc_ibv_post_send(struct ibv_qp *qp, struct ibv_send_wr *wr,
struct ibv_send_wr **bad_wr)
{
struct pc_hca *hca;
uint16_t lid;
double s, e;
s = get_dtime();
if (init_hcas_q == 0) {
return;
}
if (wr->opcode == IBV_WR_RDMA_WRITE)
{
lid = get_lid(qp->context);
hca = get_pc_hca(lid);
if (hca == NULL) {
return ;
}
struct pc_length *len = (struct pc_length*)malloc(sizeof(struct pc_length));
len->ctx = qp->context;
len->length = wr->sg_list->length;
lq_enq(&pc_q, len);
pthread_mutex_lock(&pc_mutex);
hca->co->pdg_num++;
hca->co->pdg_size += wr->sg_list->length;
pthread_mutex_unlock(&pc_mutex);
#ifdef DEBUG
fprintf(stderr, "[ %f ] post_send : pdg_num: %lu , pdg_size: %lu\n", get_dtime(), hca->co->pdg_num, hca->co->pdg_size);
#ifdef DETAIL
fprintf(stderr, "\tqp:%p, send_cq: %p, recv_cq: %p, context: %p, qp_context: %p\n", qp, qp->send_cq, qp->recv_cq, qp->context, qp->qp_context);
fprintf(stderr, "\twr_id:%lu, length:%d, opcode:%d, send_flags%d, imm_data:%u, remote_add:%lu, rkey:%u, xrc_remote_srq_num:%u\n", wr->wr_id, wr->sg_list->length, wr->opcode, wr->send_flags, wr->imm_data, wr->wr.rdma.remote_addr, wr->wr.rdma.rkey, wr->xrc_remote_srq_num);
fprintf(stderr, "\ttime:%f\n", get_dtime() - s);
#endif
#endif
}
return;
}
int nbcr_nn_end(nbcr_comm *comm)
{
double ts, tp;
ts = get_dtime();
tp = ts - comm->perfc->ts_nn;
if (comm->perfc->tp_nn > tp) {
comm->perfc->tp_nn = tp;
}
return 0;
}
void* memlock(void* size)
{
int* s;
char* a;
double ss,ee;
int i;
s = (int *)size;
a = (char *)valloc(*s);
// printf("%d \n", sizeof(a));
// memset(a, 0, *s);
// for (i = 0; i < *s; i++) {
// a[i] = 'x';
// }
ss = get_dtime();
mlock(a,*s);
ee = get_dtime();
fprintf(stderr, "Size: %d, Time: %f\n", *s, ee - ss);
return;
}
int TEST_RDMA_transfer (char* host, char* src, char* dst)
{
// uint64_t size;
// int flag1, flag2;
struct RDMA_communicator comm;
struct RDMA_param param;
double st, et;
int i;
param.host = host;
RDMA_Active_Init(&comm, ¶m);
st = get_dtime();
for (i = 0; i < 12; i++){
char path[1024];
sprintf(path, "%s.%d", dst, i);
RDMA_transfer(src, path, 200000000, 2, &comm);
}
et = get_dtime();
printf("ACT: Total time= %f\n", et - st);
// RDMA_Active_Finalize(&comm);
return 0;
}
void __pc_ibv_poll_cq(struct ibv_cq *cq, int num_entries, struct ibv_wc *wc)
{
struct pc_length *len;
if (init_hcas_q == 0) {
return;
}
if (wc->opcode == IBV_WC_RDMA_WRITE) {
lq_init_it(&pc_q);
while ((len = (struct pc_length*)lq_next(&pc_q)) != NULL) {
struct pc_hca *hca;
uint16_t lid;
if (len->ctx == cq->context) {
lid = get_lid(cq->context);
hca = get_pc_hca(lid);
pthread_mutex_lock(&pc_mutex);
hca->co->pdg_num--;
hca->co->pdg_size = hca->co->pdg_size - len->length;
pthread_mutex_unlock(&pc_mutex);
lq_remove(&pc_q, len);
free(len);
lq_fin_it(&pc_q);
#ifdef DEBUG
fprintf(stderr, "[ %f ] post_cq : pdg_num: %lu , pdg_size: %lu \n", get_dtime(), hca->co->pdg_num, hca->co->pdg_size);
#ifdef DETAIL
struct ibv_port_attr pattr;
ibv_query_port(cq->context, 1, &pattr);
fprintf(stderr, "\tcp:%p, context:%p(more_ops:%p, abi_compat:%p, num_comp_vectors:%d, slid:%u), :\n", cq, cq->context, cq->context->more_ops, cq->context->abi_compat, cq->context->num_comp_vectors, pattr.lid);
fprintf(stderr, "\twr_id:%lu, status:%d, wc->opcode:%d, vendor_err:%u, byte_len:%u, imm_data:%u, qp_num:%p src_qp:%p, wc_flags:%d, pkey_index:%u, slid:%u, sl:%u, dlid_path_bits:%u, num_entries:%d \n", wc->wr_id, wc->status, wc->opcode, wc->vendor_err, wc->byte_len, wc->imm_data, wc->qp_num, wc->src_qp, wc->wc_flags, wc->pkey_index, wc->slid, wc->sl, wc->dlid_path_bits, num_entries);
#endif
#endif
return;
}
}
lq_fin_it(&pc_q);
}
return;
}
int nbcr_nn_start(nbcr_comm *comm)
{
comm->perfc->ts_nn = get_dtime();
return 0;
}
void play_hmi (void * arg)
{
int i;
int pos = 0x308;
int n_chunks = 0;
int low_dtime;
int low_chunk;
int csec;
// pid_t loc_pid;
int qid;
int ipc_read = 0;
int k=0;
struct msgbuf *rcv;
Track_info *t_info;
//printf ("play_hmi\n");//#########
stop = 0;
ipc_read=0;
// loc_pid=fork();
/* switch (loc_pid)
{
case 0:
break;
case -1:
return -1;
default:
atexit(kill_ipc);
return loc_pid;
}*/
// signal(SIGTERM, my_quit);
rcv=d_malloc(sizeof(long) + 16);
rcv->mtype=1;
rcv->mtext[0]='0';
sleep(2);
qid=msgget ((key_t) ('l'<<24) | ('d'<<16) | ('e'<<8) | 's', 0660);
if(qid == -1)
{
return;
}
do
{
ipc_read=do_ipc(qid,rcv,0);
}
while(rcv->mtext[0] != 'p');
stop=0;
rcv->mtext[0] = '0';
seq_init();
n_chunks=data[0x30];
t_info = d_malloc(sizeof(Track_info)*n_chunks);
while(1)
{
for(i=0;i<n_chunks;i++)
{
t_info[i].position = pos + 12;
t_info[i].status = PLAYING;
t_info[i].time = get_dtime(data,&t_info[i].position);
pos += (( (0xff & data[pos + 5]) << 8 ) + (0xff & data[pos + 4]);
}
SEQ_START_TIMER();
do
{
low_chunk = -1;
k++;
i=0;
do
{
if (t_info[i].status == PLAYING)
low_chunk = i;
i++;
}
while((low_chunk <=0) && (i<n_chunks);
if (low_chunk == -1)
break;
low_dtime = t_info[low_chunk].time;
for(i=1;i<n_chunks;i++)
{
if ((t_info[i].time < low_dtime) &&
(t_info[i].status == PLAYING))
{
low_dtime = t_info[i].time;
low_chunk = i;
}
}
//if (low_dtime < 0)
//printf("Serious warning: d_time negative!!!!!!\n");
csec = 0.86 * low_dtime;
//flush sequencer buffer after 20 events
if (k == 20)
{
ioctl(seqfd, SNDCTL_SEQ_SYNC);
k = 0;
}
SEQ_WAIT_TIME(csec);
t_info[low_chunk].status = do_track_event(data,&t_info[low_chunk].position);
if (t_info[low_chunk].status == 3)
{
//printf("Error playing data in chunk %d\n",low_chunk);
t_info[low_chunk].status = STOPPED;
}
if (t_info[low_chunk].status == PLAYING)
t_info[low_chunk].time += get_dtime(data,&t_info[low_chunk].position);
//Check if the song has reached the end
stop = t_info[0].status;
for(i=1;i<n_chunks;i++)
stop &= t_info[i].status;
if((do_ipc(qid,rcv,IPC_NOWAIT) > 0) && (rcv->mtext[0]=='p'))
{
n_chunks=data[0x30];
t_info = realloc(t_info,sizeof(Track_info)*n_chunks);
stop = 1;
rcv->mtext[0] = '0';
stop_all();
}
}
while(!stop);
SEQ_STOP_TIMER();
if( stop == 2)
{
stop_all();
do
{
ipc_read=do_ipc(qid,rcv,0);
}
while(rcv->mtext[0] != 'p');
rcv->mtext[0] = '0';
n_chunks=data[0x30];
t_info = realloc(t_info,sizeof(Track_info)*n_chunks);
stop = 0;
}
pos=0x308;
}
d_free(data);
d_free(t_info);
d_free(rcv);
}
static int run(void)
{
struct rdma_addrinfo hints, *res;
struct ibv_qp_init_attr attr;
struct ibv_wc wc;
int ret;
memset(&hints, 0, sizeof hints);
hints.ai_port_space = RDMA_PS_TCP;
ret = rdma_getaddrinfo(server, port, &hints, &res);
if (ret) {
printf("rdma_getaddrinfo %d\n", errno);
return ret;
}
memset(&attr, 0, sizeof attr);
attr.cap.max_send_wr = attr.cap.max_recv_wr = 1;
attr.cap.max_send_sge = attr.cap.max_recv_sge = 1;
attr.cap.max_inline_data = 16;
attr.qp_context = id;
attr.sq_sig_all = 1;
ret = rdma_create_ep(&id, res, NULL, &attr);
rdma_freeaddrinfo(res);
if (ret) {
printf("rdma_create_ep %d\n", errno);
return ret;
}
mr = rdma_reg_msgs(id, recv_msg, 16);
if (!mr) {
printf("rdma_reg_msgs %d\n", errno);
return ret;
}
ret = rdma_post_recv(id, NULL, recv_msg, 16, mr);
if (ret) {
printf("rdma_post_recv %d\n", errno);
return ret;
}
ret = rdma_connect(id, NULL);
if (ret) {
printf("rdma_connect %d\n", errno);
return ret;
}
s = get_dtime();
ret = rdma_post_send(id, NULL, send_msg, 16, NULL, IBV_SEND_INLINE);
if (ret) {
printf("rdma_post_send %d\n", errno);
return ret;
}
e = get_dtime();
ret = rdma_get_recv_comp(id, &wc);
if (ret <= 0) {
printf("rdma_get_recv_comp %d\n", ret);
return ret;
}
printf("time %f\n", e - s);
rdma_disconnect(id);
rdma_dereg_mr(mr);
rdma_destroy_ep(id);
return 0;
}
void on_completion(struct ibv_wc *wc)
{
struct connection *conn = (struct connection *)(uintptr_t)wc->wr_id;
if (wc->status != IBV_WC_SUCCESS)
die("on_completion: status is not IBV_WC_SUCCESS.");
if (wc->opcode == IBV_WC_RDMA_WRITE) {
e[idx] = get_dtime();
int *v = (int*)conn->rdma_local_region;
printf("RDMA Write: %f (v=%d)\n", e[idx] - s[idx], v[0]);
idx++;
return;
} else if (wc->opcode & IBV_WC_RDMA_READ) {
// printf("RDMA Read: %f\n", e - s);
return;
}
if (wc->opcode & IBV_WC_RECV) {
conn->recv_state++;
if (conn->recv_msg->type == MSG_MR) {
memcpy(&conn->peer_mr, &conn->recv_msg->data.mr, sizeof(conn->peer_mr));
post_receives(conn); /* only rearm for MSG_MR */
if (conn->send_state == SS_INIT) /* received peer's MR before sending ours, so send ours back */
send_mr(conn);
}
} else {
conn->send_state++;
printf("send completed successfully.\n");
}
if (conn->send_state == SS_MR_SENT && conn->recv_state == RS_MR_RECV) {
struct ibv_send_wr wr, *bad_wr = NULL;
struct ibv_sge sge;
if (s_mode == M_WRITE)
printf("received MSG_MR. writing message to remote memory...\n");
else
printf("received MSG_MR. reading message from remote memory...\n");
memset(&wr, 0, sizeof(wr));
wr.wr_id = (uintptr_t)conn;
wr.opcode = (s_mode == M_WRITE) ? IBV_WR_RDMA_WRITE : IBV_WR_RDMA_READ;
wr.sg_list = &sge;
wr.num_sge = 1;
wr.send_flags = IBV_SEND_SIGNALED;
wr.wr.rdma.remote_addr = (uintptr_t)conn->peer_mr.addr;
wr.wr.rdma.rkey = conn->peer_mr.rkey;
sge.addr = (uintptr_t)conn->rdma_local_region;
sge.length = RDMA_BUFFER_SIZE;
sge.lkey = conn->rdma_local_mr->lkey;
int *v = (int*)conn->peer_mr.addr;
v[0] = 15;
int i;
for (i = 0; i < CNUM; i++) {
s[i] = get_dtime();
TEST_NZ(ibv_post_send(conn->qp, &wr, &bad_wr));
}
v[0] = 11;
conn->send_msg->type = MSG_DONE;
send_message(conn);
} else if (conn->send_state == SS_DONE_SENT && conn->recv_state == RS_DONE_RECV) {
printf("remote buffer: %s\n", get_peer_message_region(conn));
rdma_disconnect(conn->id);
}
}
//static void* poll_cq(struct RDMA_communicator* comm)
static void* poll_cq(struct poll_cq_args* args)
{
struct ibv_cq *cq;
struct ibv_wc wc;
struct connection *conn;
struct RDMA_communicator *comm;
// struct RDMA_message *msg;
double s, e;
char* ip;
struct control_msg cmsg;
void* ctx;
char* buff;
uint64_t buff_size;
int tag;
uint64_t mr_size=0;
uint64_t sent_size=0;
char* send_base_addr;
int* flag = args->flag;
int mr_index;
//for (i = 0; i < RDMA_BUF_NUM_C; i++){ rdma_msg_mr[i] = NULL;}
comm = args->comm;
buff = args->msg->buff;
send_base_addr = args->msg->buff;
buff_size= args->msg->size;
tag= args->msg->tag;
cmsg.type=MR_INIT;
cmsg.data1.buff_size=buff_size;
send_control_msg(comm->cm_id->context, &cmsg);
// fprintf(stderr, "RDMA lib: SEND: INIT: tag=%d\n", tag);
post_receives(comm->cm_id->context);
s = get_dtime();
while (1) {
if (ibv_get_cq_event(s_ctx->comp_channel, &cq, &ctx)) {
fprintf(stderr, "RDMA lib: SEND: ERROR: get cq event failed @ %s:%d", __FILE__, __LINE__);
exit(1);
}
ibv_ack_cq_events(cq, 1);
if (ibv_req_notify_cq(cq, 0)) {
fprintf(stderr, "RDMA lib: SEND: ERROR: request notification failed @ %s:%d", __FILE__, __LINE__);
exit(1);
}
while (ibv_poll_cq(cq, 1, &wc)){
conn = (struct connection *)(uintptr_t)wc.wr_id;
debug(printf("Control MSG from: %lu\n", (uintptr_t)conn->id), 1);
if (wc.status != IBV_WC_SUCCESS) {
die("RDMA lib: SEND: ERROR: on_completion: status is not IBV_WC_SUCCESS.");
}
if (wc.opcode == IBV_WC_RECV) {
switch (conn->recv_msg->type)
{
case MR_INIT_ACK:
debug(printf("Recived: Type=%d\n", conn->recv_msg->type), 1);
for (mr_index = 0; mr_index < RDMA_BUF_NUM_C; mr_index++) {
debug(printf("Recived: Type=%d\n", conn->recv_msg->type), 1);
if (sent_size == buff_size) {
/*sent all data*/
cmsg.type=MR_FIN;
cmsg.data1.tag=tag;
send_control_msg(conn, &cmsg);
// fprintf(stderr,"Yahoooooooooo !!\n");
post_receives(conn);
debug(printf("RDMA lib: SEND: Recieved MR_INIT_ACK: for tag=%d\n", tag), 1);
} else {
debug(printf("RDMA lib: SEND: Recieved MR_INIT_ACK: for tag=%d\n", tag), 1);
/*not sent all data yet*/
if (sent_size + rdma_buf_size > buff_size) {
mr_size = buff_size - sent_size;
} else {
mr_size = rdma_buf_size;
}
debug(printf("mr_size=%lu\n", mr_size),1);
// printf("%s\n", send_base_addr);
// register_rdma_region(conn, send_base_addr, mr_size);
register_rdma_msg_mr(mr_index, send_base_addr, mr_size);
send_base_addr += mr_size;
sent_size += mr_size;
cmsg.type=MR_CHUNK;
cmsg.data1.mr_size=mr_size;
memcpy(&cmsg.data.mr, rdma_msg_mr[mr_index], sizeof(struct ibv_mr));
// cmsg.data.mr = conn->rdma_msg_mr;
send_control_msg(conn, &cmsg);
// fprintf(stderr, "RDMA lib: SEND: CHUNK: tag=%d\n", tag);
post_receives(conn);
}
}
break;
case MR_CHUNK_ACK:
if (sent_size == buff_size) {
/*sent all data*/
cmsg.type=MR_FIN;
cmsg.data1.tag=tag;
debug(printf("RDMA lib: SEND: Recieved MR_CHUNK_ACK => FIN: for tag=%d\n", tag), 1);
} else {
/*not sent all data yet*/
debug(printf("RDMA lib: SEND: Recieved MR_CHUNK_ACK: for tag=%d\n", tag), 1);
if (sent_size + rdma_buf_size > buff_size) {
mr_size = buff_size - sent_size;
} else {
mr_size = rdma_buf_size;
}
debug(printf("mr_size=%lu\n", mr_size),1);
// printf("%s\n", send_base_addr);
// register_rdma_region(conn, send_base_addr, mr_size);
// mr_index = (mr_index+ 1) % RDMA_BUF_NUM_C;
mr_index = (mr_index+ 1) % RDMA_BUF_NUM_C;
debug(printf("mr_index=%d\n", mr_index),1);
register_rdma_msg_mr(mr_index, send_base_addr, mr_size);
send_base_addr += mr_size;
sent_size += mr_size;
cmsg.type=MR_CHUNK;
cmsg.data1.mr_size=mr_size;
memcpy(&cmsg.data.mr, rdma_msg_mr[mr_index], sizeof(struct ibv_mr));
// cmsg.data.mr = conn->rdma_msg_mr;
}
send_control_msg(conn, &cmsg);
// fprintf(stderr, "RDMA lib: SEND: CHUNK2: tag=%d, slid=%lu\n", tag, (uintptr_t)wc.slid);
post_receives(conn);
break;
case MR_FIN_ACK:
debug(printf("Recived: Type=%d\n", conn->recv_msg->type),1);
*flag = 1;
// rdma_disconnect(comm->cm_id);
// rdma_disconnect(conn->id);
//exit(0);
e = get_dtime();
free(args->msg);
free(args);
// fprintf(stderr, "RDMA lib: SEND: FIN_ACK: tag=%d\n", tag);
//ip = get_ip_addr("ib0");
// printf("RDMA lib: SEND: %s: send time= %f secs, send size= %lu MB, throughput = %f MB/s\n", ip, e - s, buff_size/1000000, buff_size/(e - s)/1000000.0);
return NULL;
default:
debug(printf("Unknown TYPE"), 1);
return NULL;
}
} else if (wc.opcode == IBV_WC_SEND) {
// fprintf(stderr, "RDMA lib: SENT: DONE: tag=%d\n", tag);
debug(printf("RDMA lib: SEND: Sent: TYPE=%d, tag=%d\n", conn->send_msg->type, tag),1);
} else {
die("unknow opecode.");
}
}
}
return NULL;
}
void play_hmi (void * arg)
{
int i;
int pos = 0x308;
int n_chunks = 0;
int low_dtime;
int low_chunk;
int csec, lcsec;
int qid;
int ipc_read = 0;
int k=0;
struct msgbuf *rcv;
Track_info *t_info;
con_printf(CON_DEBUG,"play_hmi\n");
stop = 0;
ipc_read=0;
rcv=malloc(sizeof(long) + 16);
rcv->mtype=1;
rcv->mtext[0]='0';
qid=msgget ((key_t) ('l'<<24) | ('d'<<16) | ('e'<<8) | 's', 0660);
if(qid == -1)
{
return;
}
do
{
ipc_read=do_ipc(qid,rcv,0);
}
while(rcv->mtext[0] != 'p');
stop=0;
rcv->mtext[0] = '0';
seq_init();
n_chunks=data[0x30];
t_info = malloc(sizeof(Track_info)*n_chunks);
while(1)
{
for(i=0;i<n_chunks;i++)
{
t_info[i].position = pos + 12;
t_info[i].status = PLAYING;
t_info[i].time = get_dtime(data,&t_info[i].position);
pos += (( (0xff & data[pos + 5]) << 8 ) + (0xff & data[pos + 4]));
}
lcsec = 0;
SEQ_START_TIMER();
do
{
low_chunk = -1;
k++;
i=0;
do
{
if (t_info[i].status == PLAYING)
low_chunk = i;
i++;
}
while((low_chunk <=0) && (i<n_chunks));
if (low_chunk == -1)
break;
low_dtime = t_info[low_chunk].time;
for(i=1;i<n_chunks;i++)
{
if ((t_info[i].time < low_dtime) &&
(t_info[i].status == PLAYING))
{
low_dtime = t_info[i].time;
low_chunk = i;
}
}
if (low_dtime < 0)
con_printf(CON_URGENT,"Serious warning: d_time negative!!!!!!\n");
csec = 0.86 * low_dtime;
//flush sequencer buffer after 20 events
if (k == 20)
{
ioctl(seqfd, SNDCTL_SEQ_SYNC);
k = 0;
}
#ifdef WANT_AWE32
cut_trough();
#endif
if (csec != lcsec) {
SEQ_WAIT_TIME(csec);
}
lcsec = csec;
t_info[low_chunk].status = do_track_event(data,&t_info[low_chunk].position);
if (t_info[low_chunk].status == 3)
{
con_printf(CON_URGENT,"Error playing data in chunk %d\n",low_chunk);
t_info[low_chunk].status = STOPPED;
}
if (t_info[low_chunk].status == PLAYING)
t_info[low_chunk].time += get_dtime(data,&t_info[low_chunk].position);
//Check if the song has reached the end
stop = t_info[0].status;
for(i=1;i<n_chunks;i++)
stop &= t_info[i].status;
if((do_ipc(qid,rcv,IPC_NOWAIT) > 0) && (rcv->mtext[0]=='p'))
{
n_chunks=data[0x30];
t_info = realloc(t_info,sizeof(Track_info)*n_chunks);
stop = 1;
rcv->mtext[0] = '0';
stop_all();
}
}
while(!stop);
SEQ_STOP_TIMER();
if( stop == 2)
{
stop_all();
do
{
ipc_read=do_ipc(qid,rcv,0);
}
while(rcv->mtext[0] != 'p');
rcv->mtext[0] = '0';
n_chunks=data[0x30];
t_info = realloc(t_info,sizeof(Track_info)*n_chunks);
stop = 0;
}
pos=0x308;
}
free(data);
free(t_info);
free(rcv);
}
int RDMA_file_transfer(char* src, char* dst, int buf_size, int count)
{
int i;
int fd;
int read_size;
int tag;
int ctl_msg_size;
struct file_buffer *fbufs;
int fbuf_index = 0;
int *flags;
int flag_init=0;
char ctl_msg[1536];
double e,s;
int send_buf = 0;
s = get_dtime();
fbufs = (struct file_buffer *)malloc(sizeof(struct file_buffer) * count);
flags = (int *)malloc(sizeof(int) * count);
for (i = 0; i < count; i++) {
fbufs[i % count].buf = (char *)malloc(buf_size);
flags[i % count] = 1;
}
// fprintf(stderr, "ACT lib: SEND: %d: src=%s dst=%s \n", file_send_count, src, dst);
/*send init*/
tag=get_tag();
sprintf(ctl_msg, "%d\t%s\t", tag, dst);
// fprintf(stderr, "ACT lib: SEND: %d: ctlmsg=%s\n", file_send_count, ctl_msg);
file_send_count++;
//printf(ctl_msg);
ctl_msg_size = strlen(ctl_msg);
flag_init = 0;
RDMA_Isendr(ctl_msg, ctl_msg_size, TRANSFER_INIT, &flag_init, &rdma_comm);
// fprintf(stderr, "ACT lib: SEND: %d: DONE ctlmsg=%s\n", file_send_count, ctl_msg);
/*---------*/
/*send file*/
fd = open(src, O_RDONLY);
read_size = buf_read(fd, fbufs[fbuf_index].buf, buf_size);
RDMA_Wait (&flag_init);
do {
// printf("sent fbuf_index=%d\n", fbuf_index);
// fprintf(stderr, "ACT lib: SEND: Befor RDNA Isendr call: ctlmsg=%s\n", ctl_msg);
flags[fbuf_index] = 0;
RDMA_Isendr(fbufs[fbuf_index].buf, read_size, tag, &flags[fbuf_index], &rdma_comm);
send_buf += read_size;
// fprintf(stderr, "ACT lib: SEND: After RDNA Isendr call: ctlmsg=%s\n", ctl_msg);
//flags[fbuf_index] = 1;
// printf("... sent done\n");
read_size = buf_read(fd, fbufs[(fbuf_index + 1) % count].buf, buf_size);
// fprintf(stderr, "ACT lib: SEND: read time = %f secs, read size = %f MB, throughput = %f MB/s: ctlmsg=%s\n", e - s, read_size/1000000.0, read_size/(e - s)/1000000.0, ctl_msg);
//fprintf(stderr, "ACT lib: SEND: Before wait: ctlmsg=%s\n", ctl_msg);
RDMA_Wait (&flags[fbuf_index]);
// fprintf(stderr, "ACT lib: SEND: After wait: ctlmsg=%s\n", ctl_msg);
fbuf_index = (fbuf_index + 1) % count;
} while (read_size > 0);
/*---------*/
/*send fin*/
sprintf(ctl_msg, "%d\t%s", tag, dst);
ctl_msg_size = strlen(ctl_msg);
RDMA_Sendr(ctl_msg, ctl_msg_size, TRANSFER_FIN, &rdma_comm);
/*---------*/
close(fd);
for (i = 0; i < count; i++) {
free(fbufs[i % count].buf);
}
free(flags);
free(fbufs);
e = get_dtime();
// fprintf(stderr, "ACT lib: SEND: file send: Time= %f , size= %d \n", e - s, send_buf);
return 0;
}
