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
}
