/* Multiply two matrices (or a matrix and a vector) and allocate the result */
CMATRIX *
cm_multiply(const CMATRIX *cm1, const CMATRIX *cm2)
{
char *rowcheck=NULL, *colcheck=NULL;
CMATRIX *cmr;
int dr, dc, i;
if ((cm1->ncols <= 0) | (cm1->ncols != cm2->nrows))
error(INTERNAL, "matrix dimension mismatch in cm_multiply()");
cmr = cm_alloc(cm1->nrows, cm2->ncols);
if (cmr == NULL)
return(NULL);
/* optimization: check for zero rows & cols */
if (((cm1->nrows > 5) | (cm2->ncols > 5)) & (cm1->ncols > 5)) {
static const COLOR czero;
rowcheck = (char *)calloc(cmr->nrows, 1);
for (dr = cm1->nrows*(rowcheck != NULL); dr--; )
for (dc = cm1->ncols; dc--; )
if (memcmp(cm_lval(cm1,dr,dc), czero, sizeof(COLOR))) {
rowcheck[dr] = 1;
break;
}
colcheck = (char *)calloc(cmr->ncols, 1);
for (dc = cm2->ncols*(colcheck != NULL); dc--; )
for (dr = cm2->nrows; dr--; )
if (memcmp(cm_lval(cm2,dr,dc), czero, sizeof(COLOR))) {
colcheck[dc] = 1;
break;
}
}
for (dr = 0; dr < cmr->nrows; dr++)
for (dc = 0; dc < cmr->ncols; dc++) {
COLORV *dp = cm_lval(cmr,dr,dc);
double res[3];
dp[0] = dp[1] = dp[2] = 0;
if (rowcheck != NULL && !rowcheck[dr])
continue;
if (colcheck != NULL && !colcheck[dc])
continue;
res[0] = res[1] = res[2] = 0;
for (i = 0; i < cm1->ncols; i++) {
const COLORV *cp1 = cm_lval(cm1,dr,i);
const COLORV *cp2 = cm_lval(cm2,i,dc);
res[0] += (double)cp1[0] * cp2[0];
res[1] += (double)cp1[1] * cp2[1];
res[2] += (double)cp1[2] * cp2[2];
}
copycolor(dp, res);
}
if (rowcheck != NULL) free(rowcheck);
if (colcheck != NULL) free(colcheck);
return(cmr);
}
/* Scale a matrix by a single value */
CMATRIX *
cm_scale(const CMATRIX *cm1, const COLOR sca)
{
CMATRIX *cmr;
int dr, dc;
cmr = cm_alloc(cm1->nrows, cm1->ncols);
if (cmr == NULL)
return(NULL);
for (dr = 0; dr < cmr->nrows; dr++)
for (dc = 0; dc < cmr->ncols; dc++) {
const COLORV *sp = cm_lval(cm1,dr,dc);
COLORV *dp = cm_lval(cmr,dr,dc);
dp[0] = sp[0] * sca[0];
dp[1] = sp[1] * sca[1];
dp[2] = sp[2] * sca[2];
}
return(cmr);
}
/* Convert general matrix to newly allocated CMATRIX buffer */
CMATRIX *
cm_from_rmatrix(const RMATRIX *rm)
{
int i, j;
CMATRIX *cnew;
if (rm == NULL || rm->ncomp != 3)
return(NULL);
cnew = cm_alloc(rm->nrows, rm->ncols);
if (cnew == NULL)
return(NULL);
for (i = cnew->nrows; i--; )
for (j = cnew->ncols; j--; ) {
COLORV *cv = cm_lval(cnew,i,j);
cv[0] = (COLORV)rmx_lval(rm,i,j,0);
cv[1] = (COLORV)rmx_lval(rm,i,j,1);
cv[2] = (COLORV)rmx_lval(rm,i,j,2);
}
return(cnew);
}
/* Extract a column vector from a matrix */
CMATRIX *
cm_column(const CMATRIX *cm, int c)
{
CMATRIX *cvr;
int dr;
if ((c < 0) | (c >= cm->ncols))
error(INTERNAL, "column requested outside matrix");
cvr = cm_alloc(cm->nrows, 1);
if (cvr == NULL)
return(NULL);
for (dr = 0; dr < cm->nrows; dr++) {
const COLORV *sp = cm_lval(cm,dr,c);
COLORV *dp = cv_lval(cvr,dr);
dp[0] = sp[0];
dp[1] = sp[1];
dp[2] = sp[2];
}
return(cvr);
}
/* Allocate and load a matrix from the given input (or stdin if NULL) */
CMATRIX *
cm_load(const char *inspec, int nrows, int ncols, int dtype)
{
const int ROWINC = 2048;
FILE *fp = stdin;
CMATRIX *cm;
if (inspec == NULL)
inspec = "<stdin>";
else if (inspec[0] == '!') {
fp = popen(inspec+1, "r");
if (fp == NULL) {
sprintf(errmsg, "cannot start command '%s'", inspec);
error(SYSTEM, errmsg);
}
} else if ((fp = fopen(inspec, "r")) == NULL) {
sprintf(errmsg, "cannot open file '%s'", inspec);
error(SYSTEM, errmsg);
}
#ifdef getc_unlocked
flockfile(fp);
#endif
if (dtype != DTascii)
SET_FILE_BINARY(fp); /* doesn't really work */
if (!dtype | !ncols) { /* expecting header? */
char *err = cm_getheader(&dtype, &nrows, &ncols, fp);
if (err != NULL)
error(USER, err);
if (ncols <= 0)
error(USER, "unspecified number of columns");
}
switch (dtype) {
case DTascii:
case DTfloat:
case DTdouble:
break;
default:
error(USER, "unexpected data type in cm_load()");
}
if (nrows <= 0) { /* don't know length? */
int guessrows = 147; /* usually big enough */
if ((dtype != DTascii) & (fp != stdin) & (inspec[0] != '!')) {
long startpos = ftell(fp);
if (fseek(fp, 0L, SEEK_END) == 0) {
long endpos = ftell(fp);
long elemsiz = 3*(dtype==DTfloat ?
sizeof(float) : sizeof(double));
if ((endpos - startpos) % (ncols*elemsiz)) {
sprintf(errmsg,
"improper length for binary file '%s'",
inspec);
error(USER, errmsg);
}
guessrows = (endpos - startpos)/(ncols*elemsiz);
if (fseek(fp, startpos, SEEK_SET) < 0) {
sprintf(errmsg,
"fseek() error on file '%s'",
inspec);
error(SYSTEM, errmsg);
}
nrows = guessrows; /* we're confident */
}
}
cm = cm_alloc(guessrows, ncols);
} else
cm = cm_alloc(nrows, ncols);
if (cm == NULL) /* XXX never happens */
return(NULL);
if (dtype == DTascii) { /* read text file */
int maxrow = (nrows > 0 ? nrows : 32000);
int r, c;
for (r = 0; r < maxrow; r++) {
if (r >= cm->nrows) /* need more space? */
cm = cm_resize(cm, cm->nrows+ROWINC);
for (c = 0; c < ncols; c++) {
COLORV *cv = cm_lval(cm,r,c);
if (fscanf(fp, COLSPEC, cv, cv+1, cv+2) != 3) {
if ((nrows <= 0) & (r > 0) & !c) {
cm = cm_resize(cm, maxrow=r);
break;
} else
goto EOFerror;
}
}
}
while ((c = getc(fp)) != EOF)
if (!isspace(c)) {
sprintf(errmsg,
"unexpected data at end of ascii input '%s'",
inspec);
error(WARNING, errmsg);
break;
}
} else { /* read binary file */
if (sizeof(COLOR) == cm_elem_size[dtype]) {
int nread = 0;
do { /* read all we can */
nread += getbinary(cm->cmem + 3*nread,
sizeof(COLOR),
cm->nrows*cm->ncols - nread,
fp);
if (nrows <= 0) { /* unknown length */
if (nread == cm->nrows*cm->ncols)
/* need more space? */
cm = cm_resize(cm, cm->nrows+ROWINC);
else if (nread && !(nread % cm->ncols))
/* seem to be done */
cm = cm_resize(cm, nread/cm->ncols);
else /* ended mid-row */
goto EOFerror;
} else if (nread < cm->nrows*cm->ncols)
goto EOFerror;
} while (nread < cm->nrows*cm->ncols);
} else if (dtype == DTdouble) {
double dc[3]; /* load from double */
COLORV *cvp = cm->cmem;
int n = nrows*ncols;
if (n <= 0)
goto not_handled;
while (n--) {
if (getbinary(dc, sizeof(double), 3, fp) != 3)
goto EOFerror;
copycolor(cvp, dc);
cvp += 3;
}
} else /* dtype == DTfloat */ {
float fc[3]; /* load from float */
COLORV *cvp = cm->cmem;
int n = nrows*ncols;
if (n <= 0)
goto not_handled;
while (n--) {
if (getbinary(fc, sizeof(float), 3, fp) != 3)
goto EOFerror;
copycolor(cvp, fc);
cvp += 3;
}
}
if (fgetc(fp) != EOF) {
sprintf(errmsg,
"unexpected data at end of binary input '%s'",
inspec);
error(WARNING, errmsg);
}
}
if (fp != stdin) {
if (inspec[0] != '!')
fclose(fp);
else if (pclose(fp)) {
sprintf(errmsg, "error running command '%s'", inspec);
error(WARNING, errmsg);
}
}
#ifdef getc_unlocked
else
funlockfile(fp);
#endif
return(cm);
EOFerror:
sprintf(errmsg, "unexpected EOF reading %s", inspec);
error(USER, errmsg);
not_handled:
error(INTERNAL, "unhandled data size or length in cm_load()");
return(NULL); /* gratis return */
}
int tmpi_bco_bcast(tmpi_BcastObj *bco, int myid, int root, char *data, unsigned int len) {
register tmpi_BCHandle *curitem;
tmpi_BCHandle *newitem;
register tmpi_BCQueue *q;
int ret;
if (bco->group_size<2) return 0; /* don't do anything */
q=bco->bco_array[root];
curitem=(tmpi_BCHandle *)ukey_getval(q->key_curhandle);
if (!curitem)
curitem=q->first;
if (curitem==(tmpi_BCHandle*)8L) {
/* internal allocation error */
return -1;
}
/* now curitem holds a handle whose avail is not -1 */
if (myid==root) { /* now avail must be zero, functioning like a lock */
/* expend the queue by one */
newitem=tmpi_bch_alloc(bco, root);
if (!newitem) {
tmpi_error(DBG_INTERNAL, "bcast failed due to insufficient memory.");
newitem=(tmpi_BCHandle*)8L;
}
else {
newitem->avail=0;
newitem->next=NULL;
}
curitem->next=newitem;
/* if ((curitem->data=anl_malloc(len))==NULL) { */
/* if ((curitem->data=mb_alloc(myid, len))==NULL) { */
if ((curitem->data=cm_alloc(len))==NULL) {
curitem->len=0;
ret=-2; /* no memory */
}
else {
memcpy(curitem->data, data, len);
curitem->len=len;
ret=0;
}
thr_mtx_lock(&(curitem->lock));
curitem->avail=1; /* the buffer is now available */
thr_cnd_bcast(&(curitem->wait));
thr_mtx_unlock(&(curitem->lock));
/* same as curitem->next, but local data will ensure faster access */
ukey_setval(q->key_curhandle, newitem);
/* better signal everybody, but don't do it now for easy debugging */
/* signalAllFlag(&(curitem->avail), 1); */
/* oh no, signalAll is too costly, why not just let recver wake by itself */
}
else { /* receivers */
thr_mtx_lock(&(curitem->lock));
while (!curitem->avail) {
thr_cnd_wait(&(curitem->wait), &(curitem->lock));
}
thr_mtx_unlock(&(curitem->lock));
if (curitem->data) {
memcpy(data, curitem->data, MIN(len, curitem->len));
ret=0;
}
else
ret=-2;
/* next item must be non-zero now */
ukey_setval(q->key_curhandle, curitem->next);
if (anf32(&(curitem->avail), 1)==bco->group_size) { /* last to leave */
if (!ret)
cm_free(curitem->data);
q->first=curitem->next;
tmpi_bch_free(bco, root, curitem);
}
}
return ret;
}