int qcs_close(qcs_link link_id) { link_data * link = (link_data *)link_id; /* check if link is valid */ if( !VALID_ID(link_id)) { ERRRET(EINVAL); } if(!ACTIVE_LINK(link)) { ERRRET(EINVAL); } /* shutdown sockets */ close(link->rx); close(link->tx); /* delete broadcast ip list */ free(link->broadcasts); /* delete link entry */ free(link); link_count--; if( link_count==0 ) { /* clean up duplicate buffer */ qcs__cleanup_dup(); } return 1; }
int qcs_waitinput( qcs_link link_id, int timeout_ms ) { link_data * link = (link_data *) link_id; struct timeval tv; fd_set fds; // check if link is valid if(!VALID_ID(link_id)) ERRRET(EINVAL); if(!ACTIVE_LINK(link)) ERRRET(EINVAL); // fill structs & select() if(timeout_ms < 0) { tv.tv_sec = 0; tv.tv_usec = 0; } else { tv.tv_sec = timeout_ms / 1000; tv.tv_usec = (timeout_ms % 1000) * 1000; } FD_ZERO(&fds); FD_SET(link->rx, &fds); return select(FD_SETSIZE, &fds, NULL, NULL, &tv); }
int qcs_recv( qcs_link link_id, qcs_msg * msg ) { link_data * link = (link_data *)link_id; char * buff; struct sockaddr_in sa; socklen_t sa_len; int retval; if(msg==NULL) ERRRET(EINVAL); if(!VALID_ID(link_id)) ERRRET(EINVAL); if(!ACTIVE_LINK(link)) ERRRET(EINVAL); buff = (char*) malloc(QCP_MAXUDPSIZE+0x10); if(buff==NULL) ERRRET(ENOMEM); // recv the data sa_len = sizeof(sa); retval = recvfrom( link->rx, (void*)buff, QCP_MAXUDPSIZE, 0, (struct sockaddr*)&sa, &sa_len ); /* check if msg is too long for us to process: * just strip it down. we guess this was the last * ascii field, in proto msg, that was soo long. */ if(retval==QCP_MAXUDPSIZE) { *(char*)(buff+QCP_MAXUDPSIZE-1)='\0'; } /* failure */ if(retval < 0) { free(buff); /* errno left from recvfrom() */ return 0; } /* parse the message */ switch(link->mode) { case QCS_PROTO_QCHAT: retval = qcs__parse_qchat_msg(buff, retval, msg); break; case QCS_PROTO_VYPRESS: retval = qcs__parse_vypress_msg(buff, retval, msg); break; } /* cleanup */ free((void*)buff); return retval; }
int qcs_rxsocket( qcs_link link_id, int * p_rxsocket ) { link_data * link = (link_data*)link_id; if(!VALID_ID(link_id)) ERRRET(EINVAL); if(!ACTIVE_LINK(link)) ERRRET(EINVAL); *p_rxsocket = link->rx; return 1; }
int qcs_send( qcs_link link_id, const qcs_msg * msg ) { const char * proto_msg; int proto_len, retval; struct sockaddr_in sab; link_data * link = (link_data *)link_id; int bcast, succ = 0; // check link if(!VALID_ID(link_id)) ERRRET(EINVAL); if(!ACTIVE_LINK(link)) ERRRET(EINVAL); // build proto message switch(link->mode) { case QCS_PROTO_VYPRESS: proto_msg = qcs__make_vypress_msg(msg, &proto_len); break; case QCS_PROTO_QCHAT: proto_msg = qcs__make_qchat_msg(msg, &proto_len); break; } if( proto_msg==NULL ) { // failed to build msg ERRRET(EINVAL); } sab.sin_family = PF_INET; sab.sin_port = htons(link->port); /* send msg to every network in bcast list */ for(bcast=0; bcast < link->broadcast_count; bcast++) { sab.sin_addr.s_addr = link->broadcasts[bcast]; retval = sendto( link->tx, proto_msg, proto_len, 0, (struct sockaddr*)&sab, sizeof(sab)); /* we return success if we managed to * send to at least one broadcast address */ succ |= retval==proto_len; } free((void*)proto_msg); if(!succ) errno = ENETUNREACH; return succ; }
/* Wrapper of pij_gassist_llr_block_buffed. Performs memory allocation and pre-calculations of * categorical mean and ratio, and the covariance matrix before invoking pij_gassist_llr_block_buffed * g: MATRIXF (ng,ns) Full genotype data matrix * t: MATRIXF (ng,ns) Supernormalized transcript data matrix for A * t2: MATRIXF (nt,ns) Supernormalized transcript data matrix for B * nv: Number of possible values for each genotype * llr1: VECTORF (end-start). Log likelihood ratios for test 1. * llr2: MATRIXF (end-start,nt). Log likelihood ratios for test 2. * llr3: MATRIXF (end-start,nt). Log likelihood ratios for test 3. * llr4: MATRIXF (end-start,nt). Log likelihood ratios for test 4. * llr5: MATRIXF (end-start,nt). Log likelihood ratios for test 5. * vb1: VECTORF (ns). Constant buffer vector, must be set to 1 initially. * Return: 0 on success. * Notes: 1. block range only applicable to A, all other transcripts as B are always considered. * 2. for each row, g must be the best eQTL of t of the same row. * 3. Definitions: ng: number of SNPs=number of transcripts for A * nt: number of transcripts for B * ns: number of samples */ static int pij_gassist_llr_block(const MATRIXG* g,const MATRIXF* t,const MATRIXF* t2,size_t nv,VECTORF* llr1,MATRIXF* llr2,MATRIXF* llr3,MATRIXF* llr4,MATRIXF* llr5,const VECTORF* vb1) { #define CLEANUP CLEANMATF(mratio)CLEANMATF(mmean1)CLEANAMMATF(mmean2,nv)CLEANAMMATF(mmb1,nv) size_t i,j; int ret; size_t ng=g->size1; size_t nt=t2->size1; MATRIXF *mratio,*mmean1; //Buffer matrix (nv,ng) struct pij_gassist_llr_block_buffed_params llp; //Memory allocation mmean1=mratio=0; AUTOCALLOC(MATRIXF*,mmean2,nv,200) AUTOCALLOC(MATRIXF*,mmb1,nv,200) if(!(mmean2&&mmb1)) ERRRET("Not enough memory.") for(i=0,j=1;i<nv;i++) j=j&&(mmean2[i]=MATRIXFF(alloc)(ng,nt))&&(mmb1[i]=MATRIXFF(alloc)(ng,nt)); mratio=MATRIXFF(alloc)(nv,ng); mmean1=MATRIXFF(alloc)(nv,ng); if(!(mratio&&mmean1&&j)) ERRRET("Not enough memory.") //Calculate ratio and mean ret=pij_gassist_llr_ratioandmean(g,t,t2,mratio,mmean1,mmean2,nv,vb1); if(ret) ERRRET("Not enough memory.") //Calculate covariance MATRIXFF(cov2_bounded)(t,t2,llr5); //Initialize parameter pack llp.ng=ng; llp.nv=nv; llp.mratio=(const MATRIXF*)mratio; llp.mmean1=(const MATRIXF*)mmean1; llp.mmean2=(const MATRIXF**)mmean2; llp.llr1=llr1; llp.llr2=llr2; llp.llr3=llr3; llp.llr4=llr4; llp.llr5=llr5; llp.mb1=mmb1; pij_gassist_llr_block_buffed(&llp); CLEANUP return 0; #undef CLEANUP }
static void setup(const char *zonename, const char *filename, const char *classname) { isc_result_t result; dns_rdataclass_t rdclass; isc_consttextregion_t region; isc_buffer_t buffer; dns_fixedname_t fixorigin; dns_name_t *origin; const char *rbt = "rbt"; if (debug) fprintf(stderr, "loading \"%s\" from \"%s\" class \"%s\"\n", zonename, filename, classname); result = dns_zone_create(&zone, mctx); ERRRET(result, "dns_zone_new"); dns_zone_settype(zone, zonetype); isc_buffer_init(&buffer, zonename, strlen(zonename)); isc_buffer_add(&buffer, strlen(zonename)); dns_fixedname_init(&fixorigin); result = dns_name_fromtext(dns_fixedname_name(&fixorigin), &buffer, dns_rootname, 0, NULL); ERRRET(result, "dns_name_fromtext"); origin = dns_fixedname_name(&fixorigin); result = dns_zone_setorigin(zone, origin); ERRRET(result, "dns_zone_setorigin"); result = dns_zone_setdbtype(zone, 1, &rbt); ERRRET(result, "dns_zone_setdatabase"); result = dns_zone_setfile(zone, filename); ERRRET(result, "dns_zone_setfile"); region.base = classname; region.length = strlen(classname); result = dns_rdataclass_fromtext(&rdclass, (isc_textregion_t *)(void*)®ion); ERRRET(result, "dns_rdataclass_fromtext"); dns_zone_setclass(zone, rdclass); if (zonetype == dns_zone_slave) dns_zone_setmasters(zone, &addr, 1); result = dns_zone_load(zone); ERRRET(result, "dns_zone_load"); result = dns_zonemgr_managezone(zonemgr, zone); ERRRET(result, "dns_zonemgr_managezone"); }
/* Calculates the ratio and mean of all transcripts (t) for genes (g) with existing buffers. * g: MATRIXG (ng,ns) genotype data, for multiple SNP and samples. Each element takes the value 0 to nv-1 * t: MATRIXF (nt,ns) of transcript data. * t2: MATRIXF (nt,ns) of transcript data for B * mratio: MATRIXF (nv,ng) of the ratio of samples for each SNP type. For return purpose. * mmean1: MATRIXF (nv,ng) of the means of each transcript among the samples of a specific SNP type. For return purpose. * mmean2: MATRIXF[nv] (ng,nt) of the means of each transcript among the samples of a specific SNP type. For return purpose. * nv: number of possible values of g. * vb: buffer. const VECTORF (ns). Must be set to 1 for all elements. * Return: 0 on success */ static int pij_gassist_llr_ratioandmean(const MATRIXG* g,const MATRIXF* t,const MATRIXF* t2,MATRIXF* mratio,MATRIXF* mmean1,MATRIXF** mmean2,size_t nv,const VECTORF* vb) { #define CLEANUP CLEANAMMATF(mb1,nv) size_t i; int ret; //Memory allocation AUTOCALLOC(MATRIXF*,mb1,nv,200) if(!mb1) ERRRET("Not enough memory.") ret=1; for(i=0;i<nv;i++) ret=ret&&(mb1[i]=MATRIXFF(alloc)(g->size1,g->size2)); if(!ret) ERRRET("Not enough memory.") pij_gassist_llr_ratioandmean_buffed(g,t,t2,mratio,mmean1,mmean2,nv,mb1,vb); CLEANUP return 0; #undef CLEANUP }
int render::exec() { cur_width = req_width; cur_height = req_height; glfwMakeContextCurrent(window); if (glewInit() != GLEW_OK) ERRRET(1, "FATAL: GLEW could not be initialized!\n"); if (!GLEW_VERSION_4_5) ERRRET(1, "FATAL: This program requires an OpenGL 4.5 compatible render device.\n"); if (!render::shader::init()) ERRRET(1, "FATAL: Shaders failed to load.\n"); if (!render::texture::init()) ERRRET(1, "FATAL: Textures failed to load.\n"); if (!render::mesh::init()) ERRRET(1, "FATAL: Meshes failed to load.\n"); if (!render::framebuffer::init(cur_width, cur_height)) ERRRET(1, "FATAL: Framebuffers failed to initialize.\n"); glClearColor(0.0f, 0.75f, 1.0f, 1.0f); glfwSwapInterval(1); while (!glfwWindowShouldClose(window)) { //Adjust Viewport and Framebuffers if necessary if (cur_width != req_width || cur_height != req_height) { cur_width = req_width; cur_height = req_height; glViewport(0, 0, cur_width, cur_height); render::framebuffer::update_framebuffer_sizes(cur_width, cur_height); } //Bind the color+glow framebuffer render::framebuffer::cc->bind(); render::framebuffer::clear(); //Draw the board render::shader::board->use(); render::texture::bind_board(); render::shader::board->uniform_transform(glm::vec3{0, 0, 0}, glm::vec3{0.0f, 0.0f, 0.0f}, glm::vec3{1.0f, 1.0f, 1.0f}); render::mesh::draw_board(); //Draw the pieces glEnable(GL_BLEND); glBlendEquationSeparate(GL_FUNC_ADD, GL_FUNC_ADD); glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ZERO); render::texture::bind_piece_pawn(); render::shader::piece->use(); game::set_board_lock(true); for (shogi::piece_placement const & piece : game::get_pieces()) { if (piece.piece->align == shogi::alignment::HOME) { render::shader::piece->uniform_color(glm::vec3{1.0f, 0.0f, 0.5f}); } else { render::shader::piece->uniform_color(glm::vec3{0.0f, 1.0f, 0.5f}); } render::shader::piece->uniform_transform(glm::vec3{piece.coords.x / 4.5f - (1.0f - (1.0f / 9)), piece.coords.y / 4.5f - (1.0f - (1.0f / 9)), 0}, glm::vec3{0.0f, 0.0f, piece.piece->align == shogi::alignment::HOME ? 0.0f : glm::radians(180.0f)}, glm::vec3{0.111111f, 0.111111f, 1.0f}); render::mesh::draw_piece(); } game::set_board_lock(false); glDisable(GL_BLEND); //Bind main framebuffer and begin first pass - diffuse render::framebuffer::use_mainfb(); render::shader::postproc_0->use(); render::framebuffer::cc->bind_as_textures(); render::mesh::draw_fullquad(); //Second pass - glow glEnable(GL_BLEND); glBlendEquationSeparate(GL_FUNC_ADD, GL_FUNC_ADD); glBlendFuncSeparate(GL_SRC_COLOR, GL_ONE, GL_ONE, GL_ZERO); render::shader::postproc_glow->use(); render::mesh::draw_fullquad(); glDisable(GL_BLEND); glfwSwapBuffers(window); } }
/** API implementation */ qcs_link qcs_open( int proto_mode, const unsigned long * broadcasts, unsigned short port ) { const int broadcast_on = 1; link_data * link; int errbak; /* check params */ if( proto_mode!=QCS_PROTO_VYPRESS && proto_mode!=QCS_PROTO_QCHAT ) { ERRRET(ENOSYS); } /* alloc link */ link = malloc(sizeof(link_data)); if(link==NULL) { ERRRET(ENOMEM); } /* setup broadcast list */ link->broadcasts = setup_bcast_list(broadcasts, &link->broadcast_count); if(link->broadcasts == NULL) { errbak = errno; free(link); ERRRET(errbak); } /* alloc sockets */ link->tx = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); if( link->tx < 0 ) { free(link); return 0; } /* switch tx to broadcast mode */ if( setsockopt(link->tx, SOL_SOCKET, SO_BROADCAST, (void*)&broadcast_on, sizeof(broadcast_on)) != 0 ) { errbak = errno; close(link->tx); free(link); ERRRET(errbak); } /* setup rx */ link->rx = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); if( link->rx < 1 ) { errbak = errno; close(link->tx); free(link); ERRRET(errbak); } if(!port) { /* adjust port */ port = 8167; } /* bind rx */ if( !bind_link(link, port)) { errbak = errno; close(link->rx); close(link->tx); free(link); ERRRET(errbak); } /* set mode */ link->mode = proto_mode; link_count ++; /* return success */ return (qcs_link)link; }
int pij_gassist_llr(const MATRIXG* g,const MATRIXF* t,const MATRIXF* t2,VECTORF* llr1,MATRIXF* llr2,MATRIXF* llr3,MATRIXF* llr4,MATRIXF* llr5,size_t nv) { #define CLEANUP CLEANVECF(vbuff1) VECTORF *vbuff1=0; //(ns) Const buffer, set to all 1. int ret; #ifndef NDEBUG size_t ng,nt,ns; ng=g->size1; nt=t2->size1; ns=t->size2; #endif //Validation assert(!((g->size2!=ns)||(t2->size2!=ns)||(t->size1!=ng)||(llr2->size1!=ng)||(llr2->size2!=nt)||(llr3->size1!=ng)||(llr3->size2!=nt)||(llr4->size1!=ng)||(llr4->size2!=nt)||(llr5->size1!=ng)||(llr5->size2!=nt))); assert(!(llr1->size!=ng)); assert(!(nv>CONST_NV_MAX)); assert(nv>MATRIXGF(max)(g)); { GTYPE tg=MATRIXGF(max)(g); if(tg>=nv) ERRRET("Maximum genotype value "PRINTFSIZET" exceeds the stated maximum possible value "PRINTFSIZET". Please check your input genotype matrix and allele count.",tg,nv-1) } //Buff unit vector vbuff1=VECTORFF(alloc)(g->size2); if(!(vbuff1)) ERRRET("Not enough memory.") VECTORFF(set_all)(vbuff1,1); ret=0; #pragma omp parallel { size_t n1,n2; int retth; threading_get_startend(t->size1,&n1,&n2); if(n2>n1) { MATRIXGF(const_view) mvg=MATRIXGF(const_submatrix)(g,n1,0,n2-n1,g->size2); MATRIXFF(const_view) mvt=MATRIXFF(const_submatrix)(t,n1,0,n2-n1,t->size2); VECTORFF(view) vvllr1; MATRIXFF(view) mvllr2,mvllr3,mvllr4,mvllr5; vvllr1=VECTORFF(subvector)(llr1,n1,n2-n1); mvllr2=MATRIXFF(submatrix)(llr2,n1,0,n2-n1,llr2->size2); mvllr3=MATRIXFF(submatrix)(llr3,n1,0,n2-n1,llr3->size2); mvllr4=MATRIXFF(submatrix)(llr4,n1,0,n2-n1,llr4->size2); mvllr5=MATRIXFF(submatrix)(llr5,n1,0,n2-n1,llr5->size2); retth=pij_gassist_llr_block(&mvg.matrix,&mvt.matrix,t2,nv,&vvllr1.vector,&mvllr2.matrix,&mvllr3.matrix,&mvllr4.matrix,&mvllr5.matrix,vbuff1); #pragma omp atomic ret+=retth; } } if(ret) ERRRET("Failed to calculate nonpermuted log likelihood ratios.") //Cleanup CLEANUP return 0; #undef CLEANUP }