Пример #1
0
void str_line_init(OBJREC *o,void **x) //source_list
  {
  o->userptr=(void *)getmem(16);
  memcpy(o->userptr,x,sizeof(*x));
  }
Пример #2
0
static void putaddr(int mode, unsigned char val) {
	unsigned short ad,ad2;
	switch(mode) {
	case abs:
		cycles+=4;
		ad=getmem(pc++);
		ad|=getmem(pc++)<<8;
		setmem(ad,val);
		return;
	case absx:
		cycles+=4;
		ad=getmem(pc++);
		ad|=getmem(pc++)<<8;
		ad2=ad+x;
		setmem(ad2,val);
		return;
	case absy:
		cycles+=4;
		ad=getmem(pc++);
		ad|=getmem(pc++)<<8;
		ad2=ad+y;
		if ((ad2&0xff00)!=(ad&0xff00)) cycles++;
		setmem(ad2,val);
		return;
	case zp:
		cycles+=3;
		ad=getmem(pc++);
		setmem(ad,val);
		return;
	case zpx:
		cycles+=4;
		ad=getmem(pc++);
		ad+=x;
		setmem(ad&0xff,val);
		return;
	case zpy:
		cycles+=4;
		ad=getmem(pc++);
		ad+=y;
		setmem(ad&0xff,val);
		return;
	case indx:
		cycles+=6;
		ad=getmem(pc++);
		ad+=x;
		ad2=getmem(ad&0xff);
		ad++;
		ad2|=getmem(ad&0xff)<<8;
		setmem(ad2,val);
		return;
	case indy:
		cycles+=5;
		ad=getmem(pc++);
		ad2=getmem(ad);
		ad2|=getmem((ad+1)&0xff)<<8;
		ad=ad2+y;
		setmem(ad,val);
		return;
	case acc:
		cycles+=2;
		a=val;
		return;
	}
}
Пример #3
0
static inline void cpuParse(unsigned char opc) {
	int cmd = opcodes[opc];
	int addr = modes[opc];
	int c;
	switch (cmd) {
	case adc:
		wval=(unsigned short)a+getaddr(addr)+((p&FLAG_C)?1:0);
		setflags(FLAG_C, wval&0x100);
		a=(unsigned char)wval;
		setflags(FLAG_Z, !a);
		setflags(FLAG_N, a&0x80);
		setflags(FLAG_V, (!!(p&FLAG_C)) ^ (!!(p&FLAG_N)));
		break;
	case and_:
		bval=getaddr(addr);
		a&=bval;
		setflags(FLAG_Z, !a);
		setflags(FLAG_N, a&0x80);
		break;
	case asl:
		wval=getaddr(addr);
		wval<<=1;
		setaddr(addr,(unsigned char)wval);
		setflags(FLAG_Z,!wval);
		setflags(FLAG_N,wval&0x80);
		setflags(FLAG_C,wval&0x100);
		break;
	case bcc:
		branch(!(p&FLAG_C));
		break;
	case bcs:
		branch(p&FLAG_C);
		break;
	case bne:
		branch(!(p&FLAG_Z));
		break;
	case beq:
		branch(p&FLAG_Z);
		break;
	case bpl:
		branch(!(p&FLAG_N));
		break;
	case bmi:
		branch(p&FLAG_N);
		break;
	case bvc:
		branch(!(p&FLAG_V));
		break;
	case bvs:
		branch(p&FLAG_V);
		break;
	case bit:
		bval=getaddr(addr);
		setflags(FLAG_Z,!(a&bval));
		setflags(FLAG_N,bval&0x80);
		setflags(FLAG_V,bval&0x40);
		break;
	case brk:
		pc=0;	/* Just quit the emulation */
		break;
	case clc:
		setflags(FLAG_C,0);
		break;
	case cld:
		setflags(FLAG_D,0);
		break;
	case cli:
		setflags(FLAG_I,0);
		break;
	case clv:
		setflags(FLAG_V,0);
		break;
	case cmp:
		bval=getaddr(addr);
		wval=(unsigned short)a-bval;
		setflags(FLAG_Z,!wval);
		setflags(FLAG_N,wval&0x80);
		setflags(FLAG_C,a>=bval);
		break;
	case cpx:
		bval=getaddr(addr);
		wval=(unsigned short)x-bval;
		setflags(FLAG_Z,!wval);
		setflags(FLAG_N,wval&0x80);
		setflags(FLAG_C,x>=bval);
		break;
	case cpy:
		bval=getaddr(addr);
		wval=(unsigned short)y-bval;
		setflags(FLAG_Z,!wval);
		setflags(FLAG_N,wval&0x80);
		setflags(FLAG_C,y>=bval);
		break;
	case dec:
		bval=getaddr(addr);
		bval--;
		setaddr(addr,bval);
		setflags(FLAG_Z,!bval);
		setflags(FLAG_N,bval&0x80);
		break;
	case dex:
		x--;
		setflags(FLAG_Z,!x);
		setflags(FLAG_N,x&0x80);
		break;
	case dey:
		y--;
		setflags(FLAG_Z,!y);
		setflags(FLAG_N,y&0x80);
		break;
	case eor:
		bval=getaddr(addr);
		a^=bval;
		setflags(FLAG_Z,!a);
		setflags(FLAG_N,a&0x80);
		break;
	case inc:
		bval=getaddr(addr);
		bval++;
		setaddr(addr,bval);
		setflags(FLAG_Z,!bval);
		setflags(FLAG_N,bval&0x80);
		break;
	case inx:
		x++;
		setflags(FLAG_Z,!x);
		setflags(FLAG_N,x&0x80);
		break;
	case iny:
		y++;
		setflags(FLAG_Z,!y);
		setflags(FLAG_N,y&0x80);
		break;
	case jmp:
		wval=getmem(pc++);
		wval|=256*getmem(pc++);
		switch (addr) {
		case abs:
			pc=wval;
			break;
		case ind:
			pc=getmem(wval);
			pc|=256*getmem(wval+1);
			break;
		}
		break;
	case jsr:
		push((pc+1)>>8);
		push((pc+1));
		wval=getmem(pc++);
		wval|=256*getmem(pc++);
		pc=wval;
		break;
	case lda:
		a=getaddr(addr);
		setflags(FLAG_Z,!a);
		setflags(FLAG_N,a&0x80);
		break;
	case ldx:
		x=getaddr(addr);
		setflags(FLAG_Z,!x);
		setflags(FLAG_N,x&0x80);
		break;
	case ldy:
		y=getaddr(addr);
		setflags(FLAG_Z,!y);
		setflags(FLAG_N,y&0x80);
		break;
	case lsr:
		bval=getaddr(addr); wval=(unsigned char)bval;
		wval>>=1;
		setaddr(addr,(unsigned char)wval);
		setflags(FLAG_Z,!wval);
		setflags(FLAG_N,wval&0x80);
		setflags(FLAG_C,bval&1);
		break;
	case nop:
		break;
	case ora:
		bval=getaddr(addr);
		a|=bval;
		setflags(FLAG_Z,!a);
		setflags(FLAG_N,a&0x80);
		break;
	case pha:
		push(a);
		break;
	case php:
		push(p);
		break;
	case pla:
		a=pop();
		setflags(FLAG_Z,!a);
		setflags(FLAG_N,a&0x80);
		break;
	case plp:
		p=pop();
		break;
	case rol:
		bval=getaddr(addr);
		c=!!(p&FLAG_C);
		setflags(FLAG_C,bval&0x80);
		bval<<=1;
		bval|=c;
		setaddr(addr,bval);
		setflags(FLAG_N,bval&0x80);
		setflags(FLAG_Z,!bval);
		break;
	case ror:
		bval=getaddr(addr);
		c=!!(p&FLAG_C);
		setflags(FLAG_C,bval&1);
		bval>>=1;
		bval|=128*c;
		setaddr(addr,bval);
		setflags(FLAG_N,bval&0x80);
		setflags(FLAG_Z,!bval);
		break;
	case rti:
		/* Treat RTI like RTS */
	case rts:
		wval=pop();
		wval|=pop()<<8;
		pc=wval+1;
		break;
	case sbc:
		bval=getaddr(addr)^0xff;
		wval=(unsigned short)a+bval+((p&FLAG_C)?1:0);
		setflags(FLAG_C, wval&0x100);
		a=(unsigned char)wval;
		setflags(FLAG_Z, !a);
		setflags(FLAG_N, a>127);
		setflags(FLAG_V, (!!(p&FLAG_C)) ^ (!!(p&FLAG_N)));
		break;
	case sec:
		setflags(FLAG_C,1);
		break;
	case sed:
		setflags(FLAG_D,1);
		break;
	case sei:
		setflags(FLAG_I,1);
		break;
	case sta:
		putaddr(addr,a);
		break;
	case stx:
		putaddr(addr,x);
		break;
	case sty:
		putaddr(addr,y);
		break;
	case tax:
		x=a;
		setflags(FLAG_Z, !x);
		setflags(FLAG_N, x&0x80);
		break;
	case tay:
		y=a;
		setflags(FLAG_Z, !y);
		setflags(FLAG_N, y&0x80);
		break;
	case tsx:
		x=s;
		setflags(FLAG_Z, !x);
		setflags(FLAG_N, x&0x80);
		break;
	case txa:
		a=x;
		setflags(FLAG_Z, !a);
		setflags(FLAG_N, a&0x80);
		break;
	case txs:
		s=x;
		break;
	case tya:
		a=y;
		setflags(FLAG_Z, !a);
		setflags(FLAG_N, a&0x80);
		break;

	case slo:
		bval = getaddr(addr);
		setflags(FLAG_C, bval >> 7);
		bval <<= 1;
		setaddr(addr, bval);
		a |= bval;
		setflags(FLAG_Z, !a);
		setflags(FLAG_N, a&0x80);
		break;

	case axs:
		x = (x & a) - getaddr(addr);
		setflags(FLAG_Z, a == 0);
		setflags(FLAG_N, a > 127);
		break;

	case lax:
		a = x = getaddr(addr);
		setflags(FLAG_Z, a == 0);
		setflags(FLAG_N, a & 0x80);
		break;

	default:
		break;
	}
}
Пример #4
0
/*
 * Returns error code equal to the HYBSVD error code (plus additional err=-6).
 *	err=0: OK
 *	err>0: SVD failed
 *	err=-1 to -5: Various SVD errors
 *	err=-6: More parameters than points
 */
int
linfit_setup(float *x,
	     float *sigma,
	     int npts,
	     int npars,
	     int nvars,
	     void (*func)(int npts, int npars, float *pars, int nvars,
			  float *xvecs, float *yvec)
	     )
{
    int i;
    int j;
    int k;
    float sum;
    float minw;
    float maxw;
    float winv;
    float *pars;
    float *a;
    float *y1;
    float *w;
    float *u;
    float *v;
    float *z;
    float *work;
    integer lnpts;
    integer lnpars;
    integer trueflag;
    integer err = 0;

    /* Note that matrices a, u, and v are passed/returned from the
     * Fortran derived routine "hybsvd_".  They are stored in column
     * order (row number cycles fastest).  The following macros hide
     * this storage convention from the user. */
#define A(i,j) a[j*npts+i]
#define U(i,j) u[j*npts+i]
#define V(i,j) v[j*npars+i]

    if (npts < npars){
	return -6;		/* System excessively singular */
    }

    /* Allocate scratch memory */
    pars = (float *)malloc(sizeof(float) * npars);
    a = (float *)malloc(sizeof(float) * npts * npars);
    y1 = (float *)malloc(sizeof(float) * npts);
    w = (float *)malloc(sizeof(float) * npars);
    u = (float *)malloc(sizeof(float) * npts * npars);
    v = (float *)malloc(sizeof(float) * npars * npars);
    z = (float *)malloc(sizeof(float) * npars * npars);
    work = (float *)malloc(sizeof(float) * npars);
    
    /* Memory for transformation matrix */
    /* (Free any memory allocated on previous calls) */
    release_memitem(yconst);
    release_memitem(transf);
    release_memitem(covar);
    yconst = (float *)getmem(sizeof(float) * npts);
    transf = (float *)getmem(sizeof(float) * npts * npars);
    covar = (float *)getmem(sizeof(float) * (npars * (npars+1))/2);

    /* Load up the "a" matrix */
    for (i=0; i<npars; pars[i++]=0);/* Clear parameter vector */
    (*func)(npts, npars, pars, nvars, x, yconst); /* Y values with null parms */
    for (i=0; i<npars; i++){
	pars[i] = 1;
	(*func)(npts, npars, pars, nvars, x, y1);
	for (j=0; j<npts; j++){
	    A(j,i) = y1[j] - yconst[j];
	}
	pars[i] = 0;
    }
    /*fprintf(stderr,"a=\n");
    for (i=0; i<npts; i++){
	for (j=0; j<npars; j++){
	    fprintf(stderr,"%12.4g ", A(i,j));
	}
	fprintf(stderr,"\n");
    }/*CMP*/

    /* Get the Singular Value Decomposition of "a" into "uwv'" */
    /* Variables needed for Fortran linkage */
    trueflag = TRUE_;
    lnpts = npts;
    lnpars = npars;
    hybsvd_(&lnpts, &lnpts, &lnpars, &lnpars, &lnpts, &lnpts, &lnpars,
	    a, w, &trueflag, u, &trueflag, v, z, NULL, &c__0, &err, work);
    if (!err){
	/* Find max "w", so we can set minimum threshold */
	maxw = w[0];
	for (i=1; i<npars; i++){
	    if (maxw < w[i]) maxw = w[i];
	}
	minw = srelpr_() * npts * maxw;

	/* Multiply out transf = vw'u' to get the transformation matrix
	 * that takes a vector of y values into parameter values.
	 */
	/* inverse(w) * u' */
	for (i=0; i<npars; i++){
	    winv = w[i] < minw ? 0 : 1 / w[i]; /* Edit singular values */
	    for (j=0; j<npts; j++){
		U(j,i) *= winv;
	    }
	}
	/* Mult on left by v */
	for (i=0; i<npars; i++){
	    for (j=0; j<npts; j++){
		TRANSF(i,j) = 0;
		for (k=0; k<npars; k++){
		    TRANSF(i,j) += V(i,k) * U(j,k);
		}
	    }
	}

	/*fprintf(stderr,"transf=\n");
	for (i=0; i<npars; i++){
	    for (j=0; j<npts; j++){
		fprintf(stderr,"%9.3g ", TRANSF(i,j));
	    }
	    fprintf(stderr,"\n");
	}/*CMP*/

	/* Get covariance matrix (assuming sigma of each point = 1 */
	for (i=0; i<npars; i++){
	    work[i] = w[i] == 0 ? 0 : 1 / (w[i] * w[i]);
	}
	for (i=0; i<npars; i++){
	    for (j=0; j<=i; j++){
		sum = 0;
		for (k=0; k<npars; k++){
		    sum += V(i,k) * V(j,k) * work[k];
		}
		COVAR(i,j) = sum;
	    }
	}
    }

    /* Release memory */
    if (pars) free(pars);
    if (a) free(a);
    if (y1) free(y1);
    if (w) free(w);
    if (u) free(u);
    if (v) free(v);
    if (z) free(z);
    if (work) free(work);

    return err;
#undef A
#undef U
#undef V
}
Пример #5
0
/*------------------------------------------------------------------------
 *  vfreemem  -  Free a memory blkaddr, returning the blkaddr to the free list
 *------------------------------------------------------------------------
 */
syscall	vfreemem(
	  char		*blkaddr,	/* Pointer to memory blkaddr	*/
	  uint32	nbytes		/* Size of blkaddr in bytes	*/
	)
{
	intmask	mask;			/* Saved interrupt mask		*/
	struct	vmemblk	*next, *prev;
	uint32	top;

	mask = disable();
	if ((nbytes == 0) || ((uint32) blkaddr < (uint32) vminheap)
			  || ((uint32) blkaddr > (uint32) vmaxheap)) {
		restore(mask);
        kprintf("vfreemem returning SYSERR\n");
		return SYSERR;
	}

    struct vmemblk* vmemlist = proctab[currpid].prvmemlist;
	prev = vmemlist;			/* Walk along free list	*/
	next = vmemlist->mnext;
	while ((next != NULL) && (next->mbegin < blkaddr)) {
		prev = next;
		next = next->mnext;
	}

	if (prev == vmemlist) {		/* Compute top of previous blkaddr*/
		top = (uint32) NULL;
	} else {
		top = (uint32) (prev->mbegin) + prev->mlength;
	}

	/* Ensure new blkaddr does not overlap previous or next blkaddrs	*/

	if (((prev != vmemlist) && (uint32) blkaddr < top)
	    || ((next != NULL)	&& (uint32) blkaddr+nbytes>(uint32)next->mbegin)) {
		restore(mask);
        kprintf("vfreemem returning SYSERR\n");
		return SYSERR;
	}

	vmemlist->mlength += nbytes;

	/* Either coalesce with previous blkaddr or add to free list */
    
    bool8 lc = (top == (uint32) blkaddr), 
          rc = (next!=NULL && blkaddr + nbytes == next->mbegin);

	if (lc && rc) { 
		prev->mlength += nbytes + next->mlength;
        prev->mnext = next->mnext;
        freemem((char*)next,sizeof(struct vmemblk));
	} else if (lc) {
        prev->mlength += nbytes;
    } else if (rc) {
        next->mbegin = blkaddr;
        next->mlength += nbytes;
    } else {
        struct vmemblk* newblk = (struct vmemblk*)getmem(sizeof(struct vmemblk));
        newblk->mbegin = blkaddr;
        newblk->mlength = nbytes;
        prev->mnext = newblk;
        newblk->mnext = next;
	}

	restore(mask);
	return OK;
}
Пример #6
0
Файл: getmem.c Проект: r9y9/SPTK
double *dgetmem(const int leng)
{
   return ((double *) getmem((size_t) leng, sizeof(double)));
}
Пример #7
0
/*------------------------------------------------------------------------
 *  x_rls  -  (command rls) list contents of remote file system directory
 *------------------------------------------------------------------------
 */
COMMAND
x_rls(int stdin, int stdout, int stderr, int nargs, char *args[])
{
	char	*p, *buf;
	int	dev, len;
	char	str[256];
	struct	dirent	{	/* UNIX directory entry		*/
		long	d_inum;	/* file's inode number		*/
		short	d_rlen;	/* length of this record	*/
		short	d_nlen;	/* length of this file's name	*/
		char	d_nam[1]; /* start of file name		*/
	};
	struct	dirent	*d;
	Bool	aflag;

	aflag = FALSE;
	if (nargs > 1 && strcmp(p=args[1],"-a") == 0) {
		nargs--;
		aflag = TRUE;
		p = args[2];
        }
	if (nargs == 1)
	  p = ".";
	else if (nargs != 2) {
		printf("Usage: rls [-a] directory\n");
		return(SYSERR);
	}
	if ( ((long)(buf=(char *)getmem(512))) == SYSERR) {
		fprintf(stderr, "rls: no memory\n");
		return(SYSERR);
	}
	if (nammap(p, buf) != RFILSYS || (dev=open(NAMESPACE, p, "ro")) == SYSERR) {
		fprintf(stderr, "cannot open %s\n", p);
		freemem(buf, 512);
		return(SYSERR);
	}
	while ( (len = read(dev, buf, 512)) > 0) {
		for (p=buf ; p< &buf[512] ; p += d->d_rlen) {
			d = (struct dirent *)p;
			/* this could be a Vax or a Sun, so be */
			/* prepared to swap integer fields     */
			if (d->d_nlen != strlen(d->d_nam)) {
			    d->d_nlen = net2hs(d->d_nlen);
			    d->d_rlen = net2hs(d->d_rlen);
			}
			
			if (d->d_inum == 0)
			  continue;
			if (len < 512 ||
			    d->d_nlen != strlen(d->d_nam) ||
			    d->d_nlen > 255 ||
			    d->d_rlen < sizeof(struct dirent) ||
			    d->d_rlen > &buf[512] - p) {
			    fprintf(stderr, "Not a directory\n");
			    close(dev);
			    freemem(buf, 512L);
			    return(SYSERR);
		        }
			if (aflag || d->d_nam[0] != '.') {
				strcpy(str, d->d_nam);
				strcat(str, "\n");
				write(stdout, str, strlen(str));
			}
			if (d->d_rlen == 0)
			  break;
		}
	}
	freemem(buf, 512);
	close(dev);
	return(OK);
}
Пример #8
0
int main(int argc, char **argv)
{
   FILE *fp = stdin;
   GMM gmm, tgmm, floor;
   double E = DEF_E, V = DEF_V, W = DEF_W,
       *dat, *pd, *cb, *icb, *logwgd, logb, *sum, *sum_m, **sum_v, diff, sum_w,
       ave_logp0, ave_logp1, change = MAXVALUE, tmp1, tmp2;
   int ispipe, l, ll, L = DEF_L, m, M = DEF_M, N, t, T = DEF_T, S =
       DEF_S, full = FULL, n1, i, j, Imin = DEF_IMIN, Imax =
       DEF_IMAX, *tindex, *cntcb;


   if ((cmnd = strrchr(argv[0], '/')) == NULL)
      cmnd = argv[0];
   else
      cmnd++;

   /* --  Check options -- */
   while (--argc)
      if (**++argv == '-') {
         switch (*(*argv + 1)) {
         case 'h':
            usage(0);
            break;
         case 'l':
            L = atoi(*++argv);
            --argc;
            break;
         case 'm':
            M = atoi(*++argv);
            --argc;
            break;
         case 't':
            T = atoi(*++argv);
            --argc;
            break;
         case 's':
            S = atoi(*++argv);
            --argc;
            break;
         case 'a':
            Imin = atoi(*++argv);
            --argc;
            break;
         case 'b':
            Imax = atoi(*++argv);
            --argc;
            break;
         case 'e':
            E = atof(*++argv);
            --argc;
            break;
         case 'v':
            V = atof(*++argv);
            --argc;
            break;
         case 'w':
            W = atof(*++argv);
            --argc;
            break;
         case 'f':
            full = 1 - full;
            break;
         default:
            fprintf(stderr, "%s: Illegal option \"%s\".\n", cmnd, *argv);
            usage(1);
         }
      } else
         fp = getfp(*argv, "rb");


   /* -- Count number of training vectors -- */
   if (T == -1) {
      ispipe = fseek(fp, 0L, SEEK_END);
      T = (int) (ftell(fp) / (double) L / (double) sizeof(float));
      rewind(fp);

      if (ispipe == -1) {       /* training data is from standard input via pipe */
         fprintf(stderr,
                 "\n %s (Error) -t option must be specified for the standard input via pipe.\n",
                 cmnd);
         usage(1);
      }
   }

   /* Memory allocation */
   /* Training data */
   dat = dgetmem(T * L);

   /* for VQ */
   N = 1;
   while (N < M)
      N *= 2;
   cb = dgetmem(N * L);
   icb = dgetmem(L);
   tindex = (int *) getmem(T, sizeof(int));
   cntcb = (int *) getmem(M, sizeof(int));

   /* GMM */
   gmm.weight = dgetmem(M);
   gmm.gauss = (Gauss *) getmem(M, sizeof(Gauss));

   for (m = 0; m < M; m++) {
      gmm.gauss[m].mean = dgetmem(L);
      gmm.gauss[m].var = dgetmem(L);

      if (full == 1) {
         gmm.gauss[m].cov = (double **) malloc(sizeof(double *) * L);
         gmm.gauss[m].inv = (double **) malloc(sizeof(double *) * L);
         for (l = 0; l < L; l++) {
            gmm.gauss[m].cov[l] = dgetmem(L);
            gmm.gauss[m].inv[l] = dgetmem(L);
         }
      }
   }

   if (full == 1) {
      floor.gauss = (Gauss *) getmem(1, sizeof(Gauss));
      floor.gauss[0].cov = (double **) malloc(sizeof(double *) * L);
      for (l = 0; l < L; l++)
         floor.gauss[0].cov[l] = dgetmem(L);
      sum_m = dgetmem(L);
      sum_v = (double **) malloc(sizeof(double *) * L);
   }
   /* temporary */
   tgmm.weight = dgetmem(M);
   tgmm.gauss = (Gauss *) getmem(M, sizeof(Gauss));

   for (m = 0; m < M; m++) {
      tgmm.gauss[m].mean = dgetmem(L);
      tgmm.gauss[m].var = dgetmem(L);

      if (full == 1) {
         tgmm.gauss[m].cov = (double **) malloc(sizeof(double *) * L);
         tgmm.gauss[m].inv = (double **) malloc(sizeof(double *) * L);
         for (l = 0; l < L; l++) {
            tgmm.gauss[m].cov[l] = dgetmem(L);
            tgmm.gauss[m].inv[l] = dgetmem(L);
         }
      }
   }

   logwgd = dgetmem(M);
   sum = dgetmem(M);

   /*  Read training data */
   freadf(dat, sizeof(*dat), T * L, fp);

   /* Initialization of GMM parameters */
   /* LBG */
   vaverage(dat, L, T, icb);
   lbg(dat, L, T, icb, 1, cb, N, ITER, MINTRAIN, S, CENTUP, DELTA, END);

   for (t = 0, pd = dat; t < T; t++, pd += L) {
      tindex[t] = vq(pd, cb, L, M);
      cntcb[tindex[t]]++;
   }

   for (m = 0; m < M; m++)
      if (cntcb[m] == 0) {
         fprintf(stderr, "Error: No data for mixture No.%d\n", m);
         usage(1);
      }

   fprintf(stderr, "T = %d  L = %d  M = %d\n", T, L, M);

   /* flooring value for weights */
   W = 1.0 / (double) M *(double) W;

   /* weights */
   for (m = 0, sum_w = 0.0; m < M; m++) {
      gmm.weight[m] = (double) cntcb[m] / (double) T;
      if (gmm.weight[m] < W)
         gmm.weight[m] = W;
      sum_w += gmm.weight[m];
   }
   if (sum_w != 1.0)
      for (m = 0; m < M; m++)
         gmm.weight[m] /= sum_w;


   /* mean */
   for (m = 0, pd = cb; m < M; m++, pd += L)
      movem(pd, gmm.gauss[m].mean, sizeof(double), L);


   /* variance */
   if (full != 1) {
      for (t = 0, pd = dat; t < T; t++, pd += L)
         for (l = 0; l < L; l++) {
            diff = gmm.gauss[tindex[t]].mean[l] - pd[l];
            gmm.gauss[tindex[t]].var[l] += sq(diff);
         }

      for (m = 0; m < M; m++)
         for (l = 0; l < L; l++) {
            gmm.gauss[m].var[l] /= (double) cntcb[m];
            if (gmm.gauss[m].var[l] < V)
               gmm.gauss[m].var[l] = V;
         }

      for (m = 0; m < M; m++)
         gmm.gauss[m].gconst = cal_gconst(gmm.gauss[m].var, L);
   }
   /* full covariance */
   else {
      for (t = 0, pd = dat; t < T; t++, pd += L) {
         for (l = 0; l < L; l++) {
            for (i = 0; i <= l; i++) {
               if (l == i) {
                  diff =
                      (gmm.gauss[tindex[t]].mean[l] -
                       pd[l]) * (gmm.gauss[tindex[t]].mean[i] - pd[i]);
                  floor.gauss[0].cov[l][i] += diff;
               }
            }
         }
      }

      for (l = 0; l < L; l++) {
         for (i = 0; i <= l; i++) {
            if (l == i) {
               floor.gauss[0].cov[l][i] /= T;
               floor.gauss[0].cov[l][i] *= V;
            }
         }
      }

      for (t = 0, pd = dat; t < T; t++, pd += L) {
         for (l = 0; l < L; l++) {
            for (i = 0; i <= l; i++) {
               diff =
                   (gmm.gauss[tindex[t]].mean[l] -
                    pd[l]) * (gmm.gauss[tindex[t]].mean[i] - pd[i]);
               gmm.gauss[tindex[t]].cov[l][i] += diff;
            }
         }
      }

      for (m = 0; m < M; m++)
         for (l = 0; l < L; l++)
            for (i = 0; i <= l; i++) {
               gmm.gauss[m].cov[l][i] /= (double) cntcb[m];
            }
   }

   /* EM training of GMM parameters */
   for (i = 0; (i <= Imax) && ((i <= Imin) || (fabs(change) > E)); i++) {
      if (full != 1)
         fillz_gmm(&tgmm, M, L);
      else
         fillz_gmmf(&tgmm, M, L);
      fillz(sum, sizeof(double), M);

      if (full != 1) {
         for (m = 0; m < M; m++)
            gmm.gauss[m].gconst = cal_gconst(gmm.gauss[m].var, L);
      } else {
         for (m = 0, n1 = 0; m < M; m++) {
            gmm.gauss[m].gconst = cal_gconstf(gmm.gauss[m].cov, L);

            if (gmm.gauss[m].gconst == 0) {
               n1++;
               for (l = 0; l < L; l++)
                  gmm.gauss[m].cov[l][l] += floor.gauss[0].cov[l][l];
               gmm.gauss[m].gconst = cal_gconstf(gmm.gauss[m].cov, L);
            }
            if (gmm.gauss[m].gconst == 0) {
               fprintf(stderr, "ERROR : Can't caluculate covdet");
               exit(EXIT_FAILURE);
            }

            /* calculate inv */
            cal_inv(gmm.gauss[m].cov, gmm.gauss[m].inv, L);
         }
      }
      if (full == 1)
         fprintf(stderr, "%d cov can't caluculate covdet\n", n1);

      for (t = 0, ave_logp1 = 0.0, pd = dat; t < T; t++, pd += L) {
         for (m = 0, logb = LZERO; m < M; m++) {
            if (full != 1) {
               logwgd[m] = log_wgd(&gmm, m, pd, L);
               logb = log_add(logb, logwgd[m]);
            }
            /* full */
            else {
               logwgd[m] = log_wgdf(&gmm, m, pd, L);
               logb = log_add(logb, logwgd[m]);
            }
         }
         ave_logp1 += logb;

         for (m = 0; m < M; m++) {
            tmp1 = exp(logwgd[m] - logb);
            sum[m] += tmp1;

            for (l = 0; l < L; l++) {
               tmp2 = tmp1 * pd[l];
               tgmm.gauss[m].mean[l] += tmp2;
               if (full != 1)
                  tgmm.gauss[m].var[l] += tmp2 * pd[l];
               else {
                  for (j = 0; j <= l; j++) {
                     tgmm.gauss[m].cov[l][j] +=
                         tmp1 * (pd[l] - gmm.gauss[m].mean[l]) * (pd[j] -
                                                                  gmm.
                                                                  gauss[m].mean
                                                                  [j]);
                  }
               }
            }
         }
      }

      /* Output average log likelihood at each iteration */
      ave_logp1 /= (double) T;
      if (i == 1 && m == 1)
         ave_logp0 = ave_logp1;

      fprintf(stderr, "iter %3d : ", i);
      fprintf(stderr, "ave_logprob = %g", ave_logp1);
      if (i) {
         change = ave_logp1 - ave_logp0;
         fprintf(stderr, "  change = %g", change);
      }
      fprintf(stderr, "\n");
      ave_logp0 = ave_logp1;

      /* Update perameters */
      /* weights */
      for (m = 0; m < M; m++)
         gmm.weight[m] = sum[m] / (double) T;

      /* mean, variance */
      for (m = 0; m < M; m++) {
         for (l = 0; l < L; l++)
            gmm.gauss[m].mean[l] = tgmm.gauss[m].mean[l] / sum[m];

         if (full != 1) {
            for (l = 0; l < L; l++) {
               gmm.gauss[m].var[l] =
                   tgmm.gauss[m].var[l] / sum[m] - sq(gmm.gauss[m].mean[l]);
               if (gmm.gauss[m].var[l] < V)
                  gmm.gauss[m].var[l] = V;
            }
         }
         /* full */
         else {
            for (l = 0; l < L; l++) {
               for (j = 0; j <= l; j++) {
                  gmm.gauss[m].cov[l][j] = tgmm.gauss[m].cov[l][j] / sum[m];
               }
            }
         }
      }
   }

   /*  Output GMM parameters */
   fwritef(gmm.weight, sizeof(double), M, stdout);
   if (full != 1) {
      for (m = 0; m < M; m++) {
         fwritef(gmm.gauss[m].mean, sizeof(double), L, stdout);
         fwritef(gmm.gauss[m].var, sizeof(double), L, stdout);
      }
   } else {
      for (m = 0; m < M; m++) {
         fwritef(gmm.gauss[m].mean, sizeof(double), L, stdout);
         for (i = 0; i < L; i++)
            for (j = 0; j < i; j++)
               gmm.gauss[m].cov[j][i] = gmm.gauss[m].cov[i][j];
         for (l = 0; l < L; l++)
            fwritef(gmm.gauss[m].cov[l], sizeof(double), L, stdout);
      }
   }
   return (0);
}
Пример #9
0
  size_t          hsc_argv_asize;
  int             i;
  struct array_object **body;
  int             len;
  size_t          strobj_size;
  size_t          strobj_asize;

  void            scan1(void){
    argv = move(argv);
    return;
  }
                  gc_init(0, 0, 0, 0);

  hsc_argv_size = sizeof(struct array_object) + argc * sizeof(struct array_object *);
  hsc_argv_asize = (hsc_argv_size + sizeof(align_t) + -1) / sizeof(align_t) * sizeof(align_t);
  hsc_argv = (struct array_object *)getmem(scan1, hsc_argv_asize);
  hsc_argv->d = (desc_t) 1;
  hsc_argv->length = argc;
  hsc_argv->el_size = sizeof(struct array_object *);
  hsc_argv->size = hsc_argv_size;
  hsc_argv->asize = hsc_argv_asize;
  body = (struct array_object **)hsc_argv->body;
  for (i = 0; i < argc; ++i) {
    len = 1 + strlen(argv[i]);
    strobj_size = sizeof(struct array_object) + len * sizeof(char);
    strobj_asize = (strobj_size + sizeof(align_t) + -1) / sizeof(align_t) * sizeof(align_t);
    body[i] = (struct array_object *)getmem(scan1, strobj_asize);
    (body[i])->d = (desc_t) 3;
    (body[i])->length = len;
    (body[i])->el_size = sizeof(char);
    (body[i])->size = strobj_size;
Пример #10
0
/*------------------------------------------------------------------------
 * snleaf - perform the requested operation on the leaf SNMP variable
 *------------------------------------------------------------------------
 */
int
snleaf(struct snbentry *bindl, struct mib_info *mip, int op)
{
	int 		len;
	char		*strp;
	struct oid	*oip;
	

	if (op == SOP_GETN) {
		if (mip->mi_next)
			return((*mip->mi_next->mi_func)
				(bindl, mip->mi_next, SOP_GETF));
		return SERR_NO_SUCH;
	}
	if (op == SOP_SET) {
		if (! mip->mi_writable)
			return SERR_NO_SUCH;
		switch(mip->mi_vartype) {
		case ASN1_INT:
			if (SVTYPE(bindl) != ASN1_INT)
				return SERR_BAD_VALUE;
			if (mip->mi_param == 0)
				return SERR_NO_SUCH;
			*((int *) mip->mi_param) = SVINT(bindl);
			break;
		case ASN1_OCTSTR:
			if (SVTYPE(bindl) != ASN1_OCTSTR)
				return SERR_BAD_VALUE;
			strp = (char *) mip->mi_param;
			memcpy(strp, SVSTR(bindl), SVSTRLEN(bindl));
			*(strp + SVSTRLEN(bindl)) = '\0';
			break;
		case ASN1_OBJID:
			if (SVTYPE(bindl) != ASN1_OBJID)
				return SERR_BAD_VALUE;
			oip = (struct oid *) mip->mi_param;
			oip->len = SVSTRLEN(bindl);
			memcpy(oip->id, SVSTR(bindl), oip->len * 2);
			break;
		}
		return SNMP_OK;
	}
	if (op == SOP_GETF) {
		/* put the correct objid into the binding list. */
		bindl->sb_oid.len = mip->mi_objid.len;
		memcpy(bindl->sb_oid.id, mip->mi_objid.id,
			mip->mi_objid.len * 2);
	}
	SVTYPE(bindl) = mip->mi_vartype;

	switch(mip->mi_vartype) {
	case ASN1_INT:
	case ASN1_TIMETICKS:
	case ASN1_GAUGE:
	case ASN1_COUNTER:
/* kprintf("snleaf: grabbed %d\n", *((int *) mip->mi_param)); */
		SVINT(bindl) = *((int *) mip->mi_param);
		break;
	case ASN1_OCTSTR:
		strp = mip->mi_param;
		if (strp == NULL) {
			SVSTRLEN(bindl) = 0;
			SVSTR(bindl) = NULL;
			break;
		}
		len = SVSTRLEN(bindl) = strlen(strp);
		SVSTR(bindl) = (char *) getmem(len);
		memcpy(SVSTR(bindl), strp, len);
		break;
	case ASN1_OBJID:
		oip = (struct oid *) mip->mi_param;
		SVOIDLEN(bindl) = oip->len;
		memcpy(SVOID(bindl), oip->id, oip->len * 2);
		break;
	}
	return SNMP_OK;
}
Пример #11
0
void printmem(const char *str, u2_t addr)
{
	printf("%s %04x: %04x\n", str, addr, (int) getmem(addr));
}
Пример #12
0
static struct rr* dnskey_cdnskey_parse(char *name, long ttl, int type, char *s)
{
    struct rr_dnskey *rr = getmem(sizeof(*rr));
    struct binary_data key;
    int flags, proto, algorithm;
    unsigned int ac;
    int i;
    static struct rr *result;

    flags = extract_integer(&s, "flags", NULL);
    if (flags < 0) return NULL;
    if (flags & 0xfe7e)
        return bitch("reserved flags bits are set");
    if (flags & 0x0001 && !(flags & 0x0100))
        return bitch("SEP bit is set but Zone Key bit is unset");
    rr->flags = flags;

    /* TODO validate that `name` is the name of the zone if flags have Zone Key bit set */

    proto = extract_integer(&s, "protocol", NULL);
    if (proto < 0) return NULL;
    if (proto != 3)
        return bitch("bad protocol value");
    rr->protocol = proto;

    algorithm = extract_algorithm(&s, "algorithm");
    if (algorithm == ALG_UNSUPPORTED)   return NULL;
    if (algorithm == ALG_PRIVATEDNS || algorithm == ALG_PRIVATEOID) {
        return bitch("private algorithms are not supported in %s", type == T_CDNSKEY ? "CDNSKEY" : "DNSKEY");
    }
    rr->algorithm = algorithm;

    key = extract_base64_binary_data(&s, "public key");
    if (key.length < 0) return NULL;
    /* TODO validate key length based on algorithm */
    rr->pubkey = key;

    ac = 0;
    ac += rr->flags;
    ac += rr->protocol << 8;
    ac += rr->algorithm;
    for (i = 0; i < rr->pubkey.length; i++) {
        ac += (i & 1) ? (unsigned char)rr->pubkey.data[i] : ((unsigned char)rr->pubkey.data[i]) << 8;
    }
    ac += (ac >> 16) & 0xFFFF;
    rr->key_tag = ac & 0xFFFF;

    rr->pkey_built = 0;
    rr->pkey = NULL;
    rr->key_type = KEY_TYPE_UNUSED;

    if (*s) {
        return bitch("garbage after valid %s data", type == T_CDNSKEY ? "CDNSKEY" : "DNSKEY");
    }
    result = store_record(type, name, ttl, rr);
    if (result && type == T_DNSKEY) {
        rr->next_key = all_dns_keys;
        all_dns_keys = rr;
    }
    return result;
}
Пример #13
0
/*------------------------------------------------------------------------
 *  rdsInit - initialize the remote disk system device
 *------------------------------------------------------------------------
 */
devcall	rdsInit (
	  struct dentry	*devptr		/* entry in device switch table	*/
	)
{
	struct	rdscblk	*rdptr;		/* ptr to device contol block	*/
	struct	rdbuff	*bptr;		/* ptr to buffer in memory	*/
					/*    used to form linked list	*/
	struct	rdbuff	*pptr;		/* ptr to previous buff on list	*/
	struct	rdbuff	*buffend;	/* last address in buffer memory*/
	uint32	size;			/* total size of memory needed	*/
					/*    buffers			*/

	/* Obtain address of control block */

	rdptr = &rdstab[devptr->dvminor];

	/* Set control block to unused */

	rdptr->rd_state = RD_FREE;
	rdptr->rd_id[0] = NULLCH;
	
	/* Set initial message sequence number */

	rdptr->rd_seq = 1;

	/* Initialize request queue and cache to empty */

	rdptr->rd_rhnext = (struct rdbuff *) &rdptr->rd_rtnext;
	rdptr->rd_rhprev = (struct rdbuff *)NULL;

	rdptr->rd_rtnext = (struct rdbuff *)NULL;
	rdptr->rd_rtprev = (struct rdbuff *) &rdptr->rd_rhnext;


	rdptr->rd_chnext = (struct rdbuff *) &rdptr->rd_ctnext;
	rdptr->rd_chprev = (struct rdbuff *)NULL;

	rdptr->rd_ctnext = (struct rdbuff *)NULL;
	rdptr->rd_ctprev = (struct rdbuff *) &rdptr->rd_chnext;

	/* Allocate memory for a set of buffers (actually request	*/
	/*    blocks and link them to form the initial free list	*/

	size = sizeof(struct rdbuff) * RD_BUFFS;

	bptr = (struct rdbuff *)getmem(size);
	rdptr->rd_free = bptr;

	if ((int32)bptr == SYSERR) {
		panic("Cannot allocate memory for remote disk buffers");
	}

	pptr = (struct rdbuff *) NULL;	/* to avoid a compiler warning */
	buffend = (struct rdbuff *) ((char *)bptr + size);
	while (bptr < buffend) {	/* walk through memory */
		pptr = bptr;
		bptr = (struct rdbuff *)
				(sizeof(struct rdbuff)+ (char *)bptr);
		pptr->rd_status = RD_INVALID;	/* buffer is empty	*/
		pptr->rd_next = bptr;		/* point to next buffer */
	}
	pptr->rd_next = (struct rdbuff *) NULL;	/* last buffer on list	*/

	/* Create the request list and available buffer semaphores */

	rdptr->rd_availsem = semcreate(RD_BUFFS);
	rdptr->rd_reqsem   = semcreate(0);

	/* Set the server IP address, server port, and local port */

	if ( dot2ip(RD_SERVER_IP, &rdptr->rd_ser_ip) == SYSERR ) {
		panic("invalid IP address for remote disk server");
	}

	/* Set the port numbers */

	rdptr->rd_ser_port = RD_SERVER_PORT;
	rdptr->rd_loc_port = RD_LOC_PORT + devptr->dvminor;

	/* Specify that the server port is not yet registered */

	rdptr->rd_registered = FALSE;

	/* Create a communication process, but leave it suspended */

	rdptr->rd_comproc = create(rdsprocess, RD_STACK, RD_PRIO,
						"rdsproc", 1, rdptr);

	if (rdptr->rd_comproc == SYSERR) {
		panic("Cannot create remote disk process");
	}
	rdptr->rd_comruns = FALSE;

	return OK;
}
Пример #14
0
Файл: vc.c Проект: EQ4/SPTK
int main(int argc, char **argv)
{
   size_t i, source_vlen = DEF_L, target_vlen = 0, len_total = 0, num_mix =
       DEF_M, total_frame = 0;
   char *coef = NULL, **dw_fn = (char **) getmem(argc, sizeof(*(dw_fn)));
   int j, k, dw_num = 1, dw_calccoef = -1, dw_coeflen = 1, win_max_width = 0;
   double floor = FLOOR;
   double *source = NULL, *target = NULL, *gv_mean = NULL, *gv_vari = NULL;
   FILE *fp = stdin, *fgmm = NULL, *fgv = NULL;
   Boolean full = TR;
   GMM gmm;
   DELTAWINDOW window;

   memset(dw_fn, 0, argc * sizeof(*dw_fn));

   if ((cmnd = strrchr(argv[0], '/')) == NULL) {
      cmnd = argv[0];
   } else {
      cmnd++;
   }
   while (--argc) {
      if (**++argv == '-') {
         switch (*(*argv + 1)) {
         case 'l':
            source_vlen = atoi(*++argv);
            --argc;
            break;
         case 'n':
            source_vlen = atoi(*++argv) + 1;
            --argc;
            break;
         case 'L':
            target_vlen = atoi(*++argv);
            --argc;
            break;
         case 'N':
            target_vlen = atoi(*++argv) + 1;
            --argc;
            break;
         case 'm':
            num_mix = atoi(*++argv);
            --argc;
            break;
         case 'd':
            if (dw_calccoef == 1 || dw_calccoef == 2) {
               fprintf(stderr,
                       "%s : Options '-r' and '-d' should not be defined simultaneously!\n",
                       cmnd);
               usage(EXIT_FAILURE);
            }
            dw_calccoef = 0;
            if (isfloat(*++argv)) {
               dw_coeflen = 0;
               for (k = 0; (k < argc - 1) && isfloat(argv[k]); k++) {
                  dw_coeflen += strlen(argv[k]) + 1;
               }
               dw_coeflen += 1;
               coef = dw_fn[dw_num] = getmem(dw_coeflen, sizeof(*coef));
               for (j = 0; j < k; j++) {
                  sprintf(coef, " %s", *argv);
                  coef += strlen(*argv) + 1;
                  if (j < k - 1) {
                     argv++;
                     argc--;
                  }
               }
            } else {
               dw_fn[dw_num] = getmem(strlen(*argv) + 1, sizeof(**dw_fn));
               strncpy(dw_fn[dw_num], *argv, strlen(*argv) + 1);
            }
            dw_num++;
            --argc;
            break;
         case 'r':
            if (dw_calccoef == 0 || dw_calccoef == 2) {
               fprintf(stderr,
                       "%s : Options '-r' and '-d' should not be defined simultaneously!\n",
                       cmnd);
               usage(EXIT_FAILURE);
            }
            dw_calccoef = 1;
            dw_coeflen = atoi(*++argv);
            --argc;
            if ((dw_coeflen != 1) && (dw_coeflen != 2)) {
               fprintf(stderr,
                       "%s : Number of delta parameter should be 1 or 2!\n",
                       cmnd);
               usage(EXIT_FAILURE);
            }
            if (argc <= 1) {
               fprintf(stderr,
                       "%s : Window size for delta parameter required!\n",
                       cmnd);
               usage(EXIT_FAILURE);
            }
            dw_fn[dw_num] = getmem(strlen(*++argv) + 1, sizeof(**dw_fn));
            strncpy(dw_fn[dw_num], *argv, strlen(*argv) + 1);
            dw_num++;
            --argc;
            if (dw_coeflen == 2) {
               if (argc <= 1) {
                  fprintf(stderr,
                          "%s : Window size for delta-delta parameter required!\n",
                          cmnd);
                  usage(EXIT_FAILURE);
               }
               dw_fn[dw_num] = getmem(strlen(*++argv) + 1, sizeof(**dw_fn));
               strncpy(dw_fn[dw_num], *argv, strlen(*argv) + 1);
               dw_num++;
               --argc;
            }
            break;
         case 'g':
            fgv = getfp(*++argv, "rb");
            --argc;
            break;
         case 'e':
            floor = atof(*++argv);
            if (floor < 0.0 || isdigit(**argv) == 0) {
               fprintf(stderr,
                       "%s : '-e' option must be specified with positive value.\n",
                       cmnd);
               usage(1);
            }
            --argc;
            break;
         case 'h':
            usage(EXIT_SUCCESS);
         default:
            fprintf(stderr, "%s: Illegal option %s.\n", cmnd, *argv);
            usage(EXIT_FAILURE);
         }
      } else if (fgmm == NULL) {
         fgmm = getfp(*argv, "rb");
      } else {
         fp = getfp(*argv, "rb");
      }
   }

   if (fgmm == NULL) {
      fprintf(stderr, "%s: GMM file must be specified!\n", cmnd);
      usage(EXIT_FAILURE);
   }

   /* set dimensionarity of joint vector */
   if (target_vlen == 0) {
      target_vlen = source_vlen;
   }
   len_total = (source_vlen + target_vlen) * dw_num;

   /* read sequence of source feature vectors */
   source = read_input(fp, source_vlen, &total_frame);
   fclose(fp);
   target = dgetmem(target_vlen * total_frame);

   /* load GMM parameters */
   alloc_GMM(&gmm, num_mix, len_total, full);
   load_GMM(&gmm, fgmm);
   prepareCovInv_GMM(&gmm);
   prepareGconst_GMM(&gmm);
   fclose(fgmm);

   /* flooring for diagonal component of covariance */
   if (floor != 0.0) {
      for (i = 0; i < num_mix; i++) {
         for (j = 0; j < (int) len_total; j++) {
            gmm.gauss[i].cov[j][j] += floor;
         }
      }
   }

   /* load GV parameters */
   if (fgv != NULL) {
      gv_mean = dgetmem(target_vlen);
      gv_vari = dgetmem(target_vlen);
      freadf(gv_mean, sizeof(*gv_mean), target_vlen, fgv);
      freadf(gv_vari, sizeof(*gv_vari), target_vlen, fgv);
      fclose(fgv);
   }

   /* set window parameters */
   window.win_size = dw_num;
   window.win_l_width =
       (int *) getmem(window.win_size, sizeof(*(window.win_l_width)));
   window.win_r_width =
       (int *) getmem(window.win_size, sizeof(*(window.win_r_width)));
   window.win_coefficient =
       (double **) getmem(window.win_size, sizeof(*(window.win_coefficient)));
   window.win_l_width[0] = 0;
   window.win_r_width[0] = 0;
   window.win_coefficient[0] = dgetmem(1);
   window.win_coefficient[0][0] = 1.0;
   if (dw_calccoef == 0) {
      int fsize, dw_leng;
      FILE *fpc = NULL;
      for (i = 1; i < window.win_size; i++) {
         if (dw_fn[i][0] == ' ') {
            fsize = str2darray(dw_fn[i], &(window.win_coefficient[i]));
         } else {
            /* read from file */
            fpc = getfp(dw_fn[i], "rb");

            /* check the number of coefficients */
            fseek(fpc, 0L, SEEK_END);
            fsize = ftell(fpc) / sizeof(float);
            fseek(fpc, 0L, SEEK_SET);
            if (fsize % 2 == 0) {
               fprintf(stderr,
                       "%s : number of delta coefficients must be odd!\n",
                       cmnd);
               usage(EXIT_FAILURE);
            }

            /* read coefficients */
            window.win_coefficient[i] = dgetmem(fsize);
            freadf(window.win_coefficient[i],
                   sizeof(*(window.win_coefficient[i])), fsize, fpc);
         }

         /* set pointer */
         dw_leng = fsize / 2;
         window.win_coefficient[i] += dw_leng;
         window.win_l_width[i] = -dw_leng;
         window.win_r_width[i] = dw_leng;
      }
      fclose(fpc);
   } else if (dw_calccoef == 1) {
      int a0, a1, a2, dw_leng;
      for (i = 1; i < window.win_size; i++) {
         dw_leng = atoi(dw_fn[i]);
         if (dw_leng < 1) {
            fprintf(stderr,
                    "%s : Width for regression coefficient shuould be more than 1!\n",
                    cmnd);
            usage(EXIT_FAILURE);
         }
         window.win_l_width[i] = -dw_leng;
         window.win_r_width[i] = dw_leng;
         window.win_coefficient[i] = dgetmem(dw_leng * 2 + 1);
         window.win_coefficient[i] += dw_leng;
      }
      dw_leng = atoi(dw_fn[1]);
      for (a1 = 0, j = -dw_leng; j <= dw_leng; a1 += j * j, j++);
      for (j = -dw_leng; j <= dw_leng; j++) {
         window.win_coefficient[1][j] = (double) j / (double) a1;
      }

      if (window.win_size > 2) {
         dw_leng = atoi(dw_fn[2]);
         for (a0 = a1 = a2 = 0, j = -dw_leng; j <= dw_leng;
              a0++, a1 += j * j, a2 += j * j * j * j, j++);
         for (j = -dw_leng; j <= dw_leng; j++) {
            window.win_coefficient[2][j]
                = 2 * ((double) (a0 * j * j - a1)) /
                ((double) (a2 * a0 - a1 * a1));
         }
      }
   }
   win_max_width = window.win_r_width[0];       /* width of static window is 0 */
   for (i = 1; i < window.win_size; i++) {
      if (win_max_width < window.win_r_width[i]) {
         win_max_width = window.win_r_width[i];
      }
      if (win_max_width < -window.win_l_width[i]) {
         win_max_width = -window.win_l_width[i];
      }
   }
   window.win_max_width = win_max_width;

   /* perform conversion */
   vc(&gmm, &window, total_frame, source_vlen, target_vlen, gv_mean, gv_vari,
      source, target);

   /* output sequence of converted target static feature vectors */
   fwritef(target, sizeof(*target), target_vlen * total_frame, stdout);

   /* release memory */
   free(source);
   free(target);
   free(gv_mean);
   free(gv_vari);
   free_GMM(&gmm);
   for (i = 0; i < window.win_size; i++) {
      if (dw_fn[i]) {
         free(dw_fn[i]);
      }
      free(window.win_coefficient[i] + window.win_l_width[i]);
   }
   free(dw_fn);
   free(window.win_l_width);
   free(window.win_r_width);
   free(window.win_coefficient);

   return (0);
}
Пример #15
0
Файл: getmem.c Проект: r9y9/SPTK
short *sgetmem(const int leng)
{
   return ((short *) getmem((size_t) leng, sizeof(short)));
}
Пример #16
0
Zufallsgenerator createZufallsgenerator() {
	Zufallsgenerator obj = ((Zufallsgenerator)getmem(sizeof(struct SZufallsgenerator)));
	return obj;
}
Пример #17
0
Файл: getmem.c Проект: r9y9/SPTK
long *lgetmem(const int leng)
{
   return ((long *) getmem((size_t) leng, sizeof(long)));
}
Пример #18
0
/*------------------------------------------------------------------------
 *  gname  -  use the DNS to look up the name
 *------------------------------------------------------------------------
 */
static IPaddr
gname(char *nam)
{
    IPaddr	ip;
    char	tmpstr[64];		/* temporary string buffer	*/
    char	*buf;			/* buffer to hold domain query	*/
    int	dg, i;
    register char	*p, *p2, *p3;
    register struct	dn_mesg *dnptr;

    dnptr = (struct dn_mesg *) (buf = (char *) getmem(DN_MLEN));
    dnptr->dn_id = 0;
    dnptr->dn_opparm = hs2net(DN_RD);
    dnptr->dn_qcount = hs2net(1);
    dnptr->dn_acount = dnptr->dn_ncount = dnptr->dn_dcount = 0;
    p = dnptr->dn_qaaa;

    strcpy(tmpstr, nam);
    p2 = tmpstr;
    while (p3=index(p2, '.')) {
        *p3 = '\0';
        dn_cat(p, p2);
        p2 = p3+1;
    }
    dn_cat(p, p2);
    *p++ = NULLCH;	/* terminate name */

    /* Add query type and query class fields to name */

    ( (struct dn_qsuf *)p )->dn_type = hs2net(DN_QTHA);
    ( (struct dn_qsuf *)p )->dn_clas = hs2net(DN_QCIN);
    p += sizeof(struct dn_qsuf);

    /* send query */

    dg = open(UDP, NSERVER, ANYLPORT);
    control(dg, DG_SETMODE, DG_DMODE | DG_TMODE);
    write (dg, buf, p - buf);
    if ( (i = read(dg, buf, DN_MLEN)) == SYSERR || i == TIMEOUT) {
        close(dg);
        freemem(buf, DN_MLEN);
        return (IPaddr)SYSERR;
    }
    close(dg);
    if (net2hs(dnptr->dn_opparm) & DN_RESP ||
            net2hs(dnptr->dn_acount) <= 0) {
        freemem(buf, DN_MLEN);
        return (IPaddr)SYSERR;
    }
    /* In answer, skip name and remainder of resource record header	*/

    while (*p != NULLCH)
        if (*p & DN_CMPRS) 	/* compressed section of name	*/
            *++p = NULLCH;
        else
            p += *p + 1;
    p += DN_RLEN + 1;

    /* Copy IP to user */

    for (i=0; i < IP_ALEN; ++i)
        ((char *)&ip)[i] = *p++;
    freemem(buf, DN_MLEN);
    return ip;
}
/**
 * @ingroup shell
 *
 * Shell command fstest.
 * @param nargs  number of arguments in args array
 * @param args   array of arguments
 * @return OK for success, SYSERR for syntax error
 */
 shellcmd xsh_fstest(int nargs, char *args[])
{
    int rval;
    int fd, i, j;
    char *buf1, *buf2;
    
    
    /* Output help, if '--help' argument was supplied */
    if (nargs == 2 && strncmp(args[1], "--help", 7) == 0)
    {
        printf("Usage: %s\n\n", args[0]);
        printf("Description:\n");
        printf("\tFilesystem Test\n");
        printf("Options:\n");
        printf("\t--help\tdisplay this help and exit\n");
        return OK;
    }

    /* Check for correct number of arguments */
    if (nargs > 1)
    {
        fprintf(stderr, "%s: too many arguments\n", args[0]);
        fprintf(stderr, "Try '%s --help' for more information\n",
                args[0]);
        return SYSERR;
    }
    if (nargs < 1)
    {
        fprintf(stderr, "%s: too few arguments\n", args[0]);
        fprintf(stderr, "Try '%s --help' for more information\n",
                args[0]);
        return SYSERR;
    }

#ifdef FS

    bs_mkdev(0, MDEV_BLOCK_SIZE, MDEV_NUM_BLOCKS); /* device "0" and default blocksize (=0) and count */
    fs_mkfs(0,DEFAULT_NUM_INODES); /* bsdev 0*/
    testbitmask();
    
    buf1 = getmem(SIZE*sizeof(char));
    buf2 = getmem(SIZE*sizeof(char));
    
    // Create test file
    fd = fs_create("Test_File", O_CREAT);
       
    // Fill buffer with random stuff
    for(i=0; i<SIZE; i++)
    {
        j = i%(127-33);
        j = j+33;
        buf1[i] = (char) j;
    }
    
    rval = fs_write(fd,buf1,SIZE);
    if(rval == 0 || rval != SIZE )
    {
        printf("\n\r File write failed");
        goto clean_up;
    }

    // Now my file offset is pointing at EOF file, i need to bring it back to start of file
    // Assuming here implementation of fs_seek is like "original_offset = original_offset + input_offset_from_fs_seek"
    fs_seek(fd,-rval); 
    
    //read the file 
    rval = fs_read(fd, buf2, rval);
    buf2[rval] = '\0';

    if(rval == 0)
    {
        printf("\n\r File read failed");
        goto clean_up;
    }
        
    printf("\n\rContent of file %s",buf2);
    
    rval = fs_close(fd);
    if(rval != OK)
    {
        printf("\n\rReturn val for fclose : %d",rval);
    }

clean_up:
    freemem(buf1,SIZE);
    freemem(buf2,SIZE);
    
#else
    printf("No filesystem support\n");
#endif

    return OK;
}
Пример #20
0
int main(int argc, char *argv[]) {
	char * bytes_count_str = NULL;
	char * devname;
	struct stat statbuf;
	int c;

	int dev;
	struct reiserfs_super_block *sb, *sb_old;
	
	while ((c = getopt(argc, argv, "fvcqs:")) != EOF) {
		switch (c) {
		case 's' :
			  if (!optarg) 
				  die("%s: Missing argument to -s option", argv[0]);		
			  bytes_count_str = optarg;
			  break;
		case 'f':
		    opt_force = 1;
		    break;		 
		case 'v':
			opt_verbose++; 
			break;
		case 'n':
			/* no nowrite option at this moment */
			/* opt_nowrite = 1; */
			break;
		case 'c':
			opt_safe = 1;
			break;
		case 'q':
			opt_verbose = 0;
			break;
		default:
			print_usage_and_exit ();
		}
	}

	if (optind == argc || (!bytes_count_str))
		print_usage_and_exit();
	devname = argv[optind];

	/* open_device will die if it could not open device */
	dev = open (devname, O_RDWR);
	if (dev == -1)
		die ("%s: can not open '%s': %s", argv[0], devname, strerror (errno));

	if (fstat (dev, &statbuf) < 0)
		die ("%s: unable to stat %s", argv[0], devname);
  
	if (!S_ISBLK (statbuf.st_mode) && opt_force )
		die ("%s: '%s (%o)' is not a block device", 
			 argv[0], devname, statbuf.st_mode);

	read_superblock(dev);
	
	sb = (struct reiserfs_super_block *) g_sb_bh->b_data;
	g_block_count_new = calc_new_fs_size(sb->s_block_count,
					     sb->s_blocksize, bytes_count_str);
	if (is_mounted (devname)) {
		close(dev);
		if (!opt_force) 
	    	die ("%s: '%s' contains a mounted file system,\n"
			     "\tspecify -f option to resize the fs online\n", 
				 argv[0], devname);
		resize_fs_online(devname, g_block_count_new);
		return 0;
	}	

	if (sb->s_state != REISERFS_VALID_FS) 
		die ("%s: the file system isn't in valid state\n", argv[0]);
		
	if(!valid_offset(dev, (loff_t) g_block_count_new * sb->s_blocksize - 1))
		die ("%s: %s too small", argv[0], devname);

	sb_old = 0;		/* Needed to keep idiot compiler from issuing false warning */
	/* save SB for reporting */
	if(opt_verbose) {
		sb_old = getmem(sizeof(struct reiserfs_super_block));
		memcpy(sb_old, sb, sizeof(struct reiserfs_super_block));
    }

	if (g_block_count_new == sb->s_block_count) 
		die ("%s: Calculated fs size is the same as the previous one.",
			 argv[0]);
	if (g_block_count_new > sb->s_block_count) 
		expand_fs();
	else
		shrink_fs(g_block_count_new);

	if(opt_verbose) {
		sb_report(sb, sb_old);
		freemem(sb_old);
	}

	check_and_free_mem ();		
	
	if (opt_verbose) {
		printf("\nSyncing..");
		fflush(stdout);
	}
	fsync (dev);
	if (opt_verbose)
		printf("done\n");
	

	close(dev);
	
	return 0;
}
Пример #21
0
object * vis_loadobject(char *fname)
{
	int	error;
	int	a,b,c;
	object	*o;
	long	l;
	char	*d,*d0;
	d=readfile(fname);
	o=getmem(sizeof(object));
	
	o->flags=F_DEFAULT;
	o->r=getmem(sizeof(rmatrix));
	o->r0=getmem(sizeof(rmatrix));
	memset(o->r,0,sizeof(rmatrix));
	memset(o->r0,0,sizeof(rmatrix));
	o->vnum=0;
	o->nnum=0;
	o->v0=NULL;
	o->n0=NULL;
	o->v=NULL;
	o->n=NULL;
	o->pv=NULL;
	o->plnum=1;
	
	for(;;)
	{
		error=0;
		d0=d;
		d+=8;
		if(!memcmp(d0,"END ",4)) break;
		else if(!memcmp(d0,"VERS",4)) 
		{
			a=GINT;
			if(a!=0x100)
			{
				printf("Version not 1.00\n");
			}
		}
		else if(!memcmp(d0,"NAME",4)) 
		{
			o->name=(char *)d;
		}
		else if(!memcmp(d0,"VERT",4)) 
		{
			o->vnum=GINT;
			GINT;
			o->v0=(vlist *)d;
			o->v=getmem(sizeof(vlist)*o->vnum);
			o->pv=getmem(sizeof(pvlist)*o->vnum);
		}
		else if(!memcmp(d0,"NORM",4))
		{
			o->nnum=GINT;
			o->nnum1=GINT;
			o->n0=(nlist *)d;
			o->n=getmem(sizeof(vlist)*o->nnum);
		}
		else if(!memcmp(d0,"POLY",4)) 
		{
			o->pd=(polydata *)d;
		}
		else if(!memcmp(d0,"ORD",3)) 
		{
			a=d0[3];
			if(a=='0') b=0;
			else if(a=='E') b=o->plnum++;
			else error=1;
			if(!error)
			{
				o->pl[b]=(polylist *)d;
			}
		}
		else error=1;
		if(error)
		{
			printf("Unknown block: %c%c%c%c\n",d0[0],d0[1],d0[2],d0[3]);
		}
		l=*(long *)(d0+4);
		d=d0+l+8;
	}

	#if 0
	printf("Sortlists: ");
	for(a=0;a<9;a++) printf("%i ",o->plv[a]);
	printf("Vertices: %i (%Fp=>%Fp=>%Fp)\n",o->vnum,o->v0,o->v,o->pv);
	printf("Normals: %i (%Fp=>%Fp)\n",o->nnum,o->n0,o->n);
	getch();
	#endif
	
	return(o);
}
Пример #22
0
int main(int argc, char **argv)
{
   FILE *pdffp = stdin, *parfp = stdout;
   int nframe, delay;
   char *coef;
   int coeflen;
   PStream pst;
   int i, j;
   void InitPStream(PStream *);
   double *mlpg(PStream *);

   pst.order = ORDER;
   pst.range = RANGE;
   pst.iType = ITYPE;
   pst.dw.fn = (char **) calloc(sizeof(char *), argc);
   pst.dw.num = 1;
   pst.dw.calccoef = -1;

   if ((cmnd = strrchr(argv[0], '/')) == NULL)
      cmnd = argv[0];
   else
      cmnd++;

   while (--argc) {
      if (**++argv == '-') {
         switch (*(*argv + 1)) {
         case 'd':
            if (pst.dw.calccoef == 1) {
               fprintf(stderr,
                       "%s : Options '-r' and '-d' should not be defined simultaneously!\n",
                       cmnd);
               return (1);
            }
            pst.dw.calccoef = 0;
            if (isfloat(*++argv)) {
               coeflen = 0;
               for (i = 0; (i < argc - 1) && isfloat(argv[i]); i++) {
                  coeflen += strlen(argv[i]) + 1;
               }
               coeflen += 1;
               coef = pst.dw.fn[pst.dw.num] = getmem(coeflen, sizeof(char));
               for (j = 0; j < i; j++) {
                  sprintf(coef, " %s", *argv);
                  coef += strlen(*argv) + 1;
                  if (j < i - 1) {
                     argv++;
                     argc--;
                  }
               }
            } else {
               pst.dw.fn[pst.dw.num] = *argv;
            }
            pst.dw.num++;
            --argc;
            break;
         case 'r':
            if (pst.dw.calccoef == 0) {
               fprintf(stderr,
                       "%s : Options '-r' and '-d' should not be defined simultaneously!\n",
                       cmnd);
               return (1);
            }
            pst.dw.calccoef = 1;
            coeflen = atoi(*++argv);
            --argc;
            if ((coeflen != 1) && (coeflen != 2)) {
               fprintf(stderr,
                       "%s : Number of delta parameter should be 1 or 2!\n",
                       cmnd);
               return (1);
            }
            if (argc <= 1) {
               fprintf(stderr,
                       "%s : Window size for delta parameter required!\n",
                       cmnd);
               return (1);
            }
            pst.dw.fn[pst.dw.num] = *++argv;
            pst.dw.num++;
            --argc;
            if (coeflen == 2) {
               if (argc <= 1) {
                  fprintf(stderr,
                          "%s : Window size for delta-delta parameter required!\n",
                          cmnd);
                  return (1);
               }
               pst.dw.fn[pst.dw.num] = *++argv;
               pst.dw.num++;
               --argc;
            }
            break;
         case 'm':
            pst.order = atoi(*++argv);
            --argc;
            break;
         case 'l':
            pst.order = atoi(*++argv) - 1;
            --argc;
            break;
         case 'i':
            pst.iType = atoi(*++argv);
            --argc;
            break;
         case 's':
            pst.range = atoi(*++argv);
            --argc;
            break;
         case 'h':
            usage(0);
         default:
            fprintf(stderr, "%s : Invalid option '%c'!\n", cmnd, *(*argv + 1));
            usage(1);
         }
      } else
         pdffp = getfp(*argv, "rb");
   }

   InitPStream(&pst);

   delay = pst.range + pst.dw.maxw[WRIGHT];
   nframe = 0;
   while (freadf(pst.mean, sizeof(*(pst.mean)), pst.vSize * 2, pdffp) ==
          pst.vSize * 2) {
      if (pst.dw.num == 1)
         fwritef(pst.mean, sizeof(*pst.mean), pst.order + 1, parfp);
      else {
         if (pst.iType == 0)
            for (i = 0; i < pst.vSize; i++)
               pst.ivar[i] = finv(pst.ivar[i]);
         mlpg(&pst);
         if (nframe >= delay)
            fwritef(pst.par, sizeof(*(pst.par)), pst.order + 1, parfp);
      }
      nframe++;
   }

   if (pst.dw.num > 1) {
      for (i = 0; i < pst.vSize; i++) {
         pst.mean[i] = 0.0;
         pst.ivar[i] = 0.0;
      }
      for (i = 0; i < min(nframe, delay); i++) {
         mlpg(&pst);
         fwritef(pst.par, sizeof(*(pst.par)), pst.order + 1, parfp);
      }
   }

   return (0);
}
Пример #23
0
MonomialOrder *monomialOrderMake(const MonomialOrdering *mo)
{
  MonomialOrder *result;
  int i, j, nv, this_block;
  deg_t *wts = NULL;
  /* Determine the number of variables, the number of blocks, and the location
     of the component */
  int nblocks = 0;
  int nvars = 0;
  int hascomponent = 0;
  for (i = 0; i < mo->len; i++)
    {
      struct mon_part_rec_ *t = mo->array[i];
      nblocks++;
      if (t->type == MO_POSITION_DOWN || t->type == MO_POSITION_UP)
        hascomponent++;
      else if (t->type == MO_NC_LEX)
        {
          // Currently, do nothing.
        }
      if (t->type != MO_WEIGHTS) nvars += t->nvars;
    }
  nblocks -= hascomponent;

  /* Now create the blocks, and fill them in. Also fill in the deg vector */
  result = getmemstructtype(MonomialOrder *);
  result->nvars = nvars;
  result->nslots = 0;
  result->nblocks = nblocks;
  result->blocks =
      (struct mo_block *)getmem(nblocks * sizeof(result->blocks[0]));
  result->degs = (deg_t *)getmem_atomic(nvars * sizeof(result->degs[0]));
  if (hascomponent == 0) result->nblocks_before_component = nblocks;

  this_block = 0;
  nvars = 0;
  for (i = 0; i < mo->len; i++)
    {
      struct mon_part_rec_ *t = mo->array[i];
      if (t->type != MO_WEIGHTS)
        {
          if (t->wts == 0)
            for (j = 0; j < t->nvars; j++) result->degs[nvars++] = 1;
          else
            for (j = 0; j < t->nvars; j++) result->degs[nvars++] = t->wts[j];
        }
      else
        {
          wts = (deg_t *)getmem_atomic(t->nvars * sizeof(wts[0]));
          for (j = 0; j < t->nvars; j++) wts[j] = t->wts[j];
        }
      switch (t->type)
        {
          case MO_REVLEX:
            mo_block_revlex(result->blocks + this_block++, t->nvars);
            break;
          case MO_GREVLEX:
            mo_block_grevlex(result->blocks + this_block++, t->nvars);
            break;
          case MO_GREVLEX2:
            mo_block_grevlex2(result->blocks + this_block++, t->nvars);
            break;
          case MO_GREVLEX4:
            mo_block_grevlex4(result->blocks + this_block++, t->nvars);
            break;
          case MO_GREVLEX_WTS:
            mo_block_grevlex_wts(result->blocks + this_block++, t->nvars);
            break;
          case MO_GREVLEX2_WTS:
            mo_block_grevlex2_wts(result->blocks + this_block++, t->nvars);
            break;
          case MO_GREVLEX4_WTS:
            mo_block_grevlex4_wts(result->blocks + this_block++, t->nvars);
            break;
          case MO_LEX:
            mo_block_lex(result->blocks + this_block++, t->nvars);
            break;
          case MO_LEX2:
            mo_block_lex2(result->blocks + this_block++, t->nvars);
            break;
          case MO_LEX4:
            mo_block_lex4(result->blocks + this_block++, t->nvars);
            break;
          case MO_WEIGHTS:
            // if extra weight values are given (more than "nvars", ignore the
            // rest.
            mo_block_wt_function(
                result->blocks + this_block++,
                (t->nvars <= result->nvars ? t->nvars : result->nvars),
                wts);
            break;
          case MO_LAURENT:
            mo_block_group_lex(result->blocks + this_block++, t->nvars);
            break;
          case MO_LAURENT_REVLEX:
            mo_block_group_revlex(result->blocks + this_block++, t->nvars);
            break;
          case MO_NC_LEX:
            /* MES */
            break;
          case MO_POSITION_UP:
            if (--hascomponent == 0)
              {
                // Set the information about the component
                result->component_up = 1;
                result->nblocks_before_component = this_block;
              }
            //  mo_block_position_up(result->blocks + this_block);
            break;
          case MO_POSITION_DOWN:
            if (--hascomponent == 0)
              {
                // Set the information about the component
                result->component_up = 0;
                result->nblocks_before_component = this_block;
              }
            //  mo_block_position_down(result->blocks + this_block);
            break;
        }
    }

  /* Go back and fill in the 'slots' information */
  /* Now fix the first_exp, first_slot values, and also result->{nslots,nvars};
   */
  nv = 0;
  result->nslots = 0;
  result->nslots_before_component = 0;
  for (i = 0; i < nblocks; i++)
    {
      enum MonomialOrdering_type typ = result->blocks[i].typ;

      result->blocks[i].first_exp = nv;
      result->blocks[i].first_slot = result->nslots;
      nv += result->blocks[i].nvars;
      result->nslots += result->blocks[i].nslots;

      if (typ == MO_WEIGHTS)
        {
          result->blocks[i].first_exp = 0;

          /* divide the wt vector by the degree vector */
          for (j = 0; j < result->blocks[i].nvars; j++)
            safe::div_by(result->blocks[i].weights[j], result->degs[j]);
          ;
        }
      else if (typ == MO_GREVLEX_WTS || typ == MO_GREVLEX2_WTS ||
               typ == MO_GREVLEX4_WTS)
        {
          result->blocks[i].weights =
              result->degs + result->blocks[i].first_exp;
        }

      if (i == result->nblocks_before_component - 1)
        {
          result->nslots_before_component = result->nslots;
        }
    }

  /* Set is_laurent */
  result->is_laurent = (int *)getmem_atomic(result->nvars * sizeof(int));
  for (i = 0; i < result->nvars; i++) result->is_laurent[i] = 0;

  for (i = 0; i < result->nblocks; i++)
    if (result->blocks[i].typ == MO_LAURENT ||
        result->blocks[i].typ == MO_LAURENT_REVLEX)
      {
        for (j = 0; j < result->blocks[i].nvars; j++)
          result->is_laurent[result->blocks[i].first_exp + j] = 1;
      }

  return result;
}
Пример #24
0
void mexFunction (int nlhs, mxArray * plhs[], int nrhs, const mxArray * prhs[]) {
		int rc, enabled;
		UINT32_T masterid = 0;
		time_t timallow = 0;
		UINT64_T memallow = 0;
		UINT64_T rss, vs;

		/* this function will be called upon unloading of the mex file */
		mexAtExit(exitFun);

		if (nrhs<3)
				mexErrMsgTxt ("invalid number of input arguments");

		if (mxIsScalar(prhs[0]))
				masterid = mxGetScalar(prhs[0]);
		else if (mxIsEmpty(prhs[0]))
				masterid = 0;
		else
				mexErrMsgTxt ("invalid input argument #1");

		if (mxIsScalar(prhs[1]))
				timallow = mxGetScalar(prhs[1]);
		else if (mxIsEmpty(prhs[1]))
				timallow = 0;
		else
				mexErrMsgTxt ("invalid input argument #2");

		if (mxIsScalar(prhs[2]))
				memallow = mxGetScalar(prhs[2]);
		else if (mxIsEmpty(prhs[2]))
				memallow = 0;
		else
				mexErrMsgTxt ("invalid input argument #3");

		if (masterid!=0 || timallow!=0 || memallow!=0) {
				enabled = 1;
				/* in this case the mex file is not allowed to be cleared from memory */
				if (!mexIsLocked())
						mexLock(); 
		}

		if (masterid==0 && timallow==0 && memallow==0) {
				enabled = 0;
				/* in this case the mex file is allowed to be cleared from memory */
#ifdef SOLUTION_FOR_UNEXPLAINED_CRASH
				if (mexIsLocked())
						mexUnlock(); 
#endif
		}

		if (!peerInitialized) {
				mexPrintf("watchdog: init\n");
				peerinit(NULL);
				peerInitialized = 1;
		}

		/* start the discover thread */
		pthread_mutex_lock(&mutexstatus);
		if (!discoverStatus) {
				pthread_mutex_unlock(&mutexstatus);
				mexPrintf("watchdog: spawning discover thread\n");
				rc = pthread_create(&discoverThread, NULL, discover, (void *)NULL);
				if (rc)
						mexErrMsgTxt("problem with return code from pthread_create()");
				else {
						/* wait until the thread has properly started */
						pthread_mutex_lock(&mutexstatus);
						if (!discoverStatus)
								pthread_cond_wait(&condstatus, &mutexstatus);
						pthread_mutex_unlock(&mutexstatus);
				}
		}
		else {
				pthread_mutex_unlock(&mutexstatus);
		}

		/* start the expire thread */
		pthread_mutex_lock(&mutexstatus);
		if (!expireStatus) {
				pthread_mutex_unlock(&mutexstatus);
				mexPrintf("watchdog: spawning expire thread\n");
				rc = pthread_create(&expireThread, NULL, expire, (void *)NULL);
				if (rc)
						mexErrMsgTxt("problem with return code from pthread_create()");
				else {
						/* wait until the thread has properly started */
						pthread_mutex_lock(&mutexstatus);
						if (!expireStatus)
								pthread_cond_wait(&condstatus, &mutexstatus);
						pthread_mutex_unlock(&mutexstatus);
				}
		}
		else {
				pthread_mutex_unlock(&mutexstatus);
		}

		if (timallow>0) {
				/* timallow should be relative to now */
				timallow += time(NULL);
		}

		if (memallow>0) {
				/* memallow should be in absolute numbers, add the current memory footprint */
				getmem(&rss, &vs);
				memallow += rss;
		}

		/* enable the watchdog: the expire thread will exit if the master is not seen any more */
		pthread_mutex_lock(&mutexwatchdog);
		watchdog.enabled  = enabled;
		watchdog.evidence = 0;
		watchdog.masterid = masterid;
		watchdog.memory   = memallow;
		watchdog.time     = timallow;
		pthread_mutex_unlock(&mutexwatchdog);

		if (enabled)
				mexPrintf("watchdog: enabled for masterid = %lu, time = %d, memory = %lu\n", masterid, timallow, memallow);
		else
				mexPrintf("watchdog: disabled for masterid = %lu, time = %d, memory = %lu\n", masterid, timallow, memallow);

		return;
} /* main */
Пример #25
0
/*-------------------------------------------------------------------------
 * pfint - paging fault ISR
 *-------------------------------------------------------------------------
 */
SYSCALL pfint()
{
		STATWORD ps;
	disable(ps);
  unsigned long int eip = read_cr2();

	//kprintf("\n\n#PF in %s, cr2:%x",proctab[currpid].pname, eip);
  unsigned long int pd_offset = eip >> 22;
  unsigned long int pt_offset = eip >>12;
  pt_offset = pt_offset & 1023;
  unsigned long offset = eip;
  offset = offset & 4095;

	//kprintf("\nEIP read is %lu\n",eip);
  eip = eip >> 12; //vpno
  //kprintf("\nEIP shifted is %lu\n",eip);

  int i = 0, flag = 0;
  int backing_store_page, bs_id;

  for(i = 0 ; i < NBS; i++)
  {
		if(proctab[currpid].map[i].pid == currpid)
		{
			//kprintf("\nif\n");
			if(proctab[currpid].map[i].next == NULL)
			{
				//kprintf("\nif if\n");
				if(proctab[currpid].map[i].vpno == eip) //we found the exact page
				{
					backing_store_page = proctab[currpid].map[i].base_page;
					flag = 1;
					//kprintf("\nif if if\n");
				}
				else if(proctab[currpid].map[i].vpno < eip && (proctab[currpid].map[i].vpno+proctab[currpid].map[i].npages) >= eip) //we found the page in the range of base_page - npages
				{
					backing_store_page = proctab[currpid].map[i].base_page + eip - proctab[currpid].map[i].vpno;
					flag = 1;
					//kprintf("\nif if else if\n");
				}
			}
			else
			{
				//kprintf("\nelse\n");
				bs_map_t *jump = &(proctab[currpid].map[i]);
				while(jump != NULL)
				{
					//kprintf("\nwhile\n");
					if(jump->vpno == eip) //we found the exact page
					{
						backing_store_page = jump->base_page;
						flag = 1;
						//kprintf("\nif else if\n");
						break;
					}
					else if(jump->vpno < eip && (jump->npages+jump->vpno) >= eip) //we found the page in the range of base_page - npages
					{
						backing_store_page = jump->base_page + eip - jump->vpno;
						flag = 1;
						//kprintf("\nif else else if\n");
						break;
					}
					jump = jump->next;
				}
			}
		}
		if(flag)
		{
			bs_id = i;
			break;
		}

  }
  //kprintf("\nin pfint bs %d, bs_page %d",bs_id,backing_store_page);

  unsigned long *bs_addr = (unsigned long *)(backing_store_page*NBPG);

	//populate page table
	//checking if page dir is empty
	
	pd_t *ptr1 = (pd_t *)(proctab[currpid].pdbr);
	//kprintf("\nbefore %d, %lu\n",ptr1,pd_offset);
	ptr1 += pd_offset; 
	pt_t *ptr;
	if(ptr1->pd_pres == 1) //page table exists hence add entry to that
	{
		ptr = (pt_t *)((ptr1->pd_base)*NBPG);
		frm_tab[(ptr1->pd_base)-FRAME0].refcnt++;
		frm_map[(ptr1->pd_base)-FRAME0].fr_refcnt++;
	}
	else //we need to create a page table, add our free_frm entry to it and add the page table entry to the directory
	{
		//kprintf("\nin else %d\n",ptr1);

		int pt_frame = get_frm();
		frm_tab[pt_frame-FRAME0].status = FRM_PGT;
		frm_tab[pt_frame-FRAME0].refcnt++;

		frm_map[pt_frame-FRAME0].fr_status = FRM_MAPPED;
		frm_map[pt_frame-FRAME0].fr_pid = currpid;
		frm_map[pt_frame-FRAME0].fr_refcnt++;
		frm_map[pt_frame-FRAME0].fr_type = FR_TBL;

		ptr = (pt_t*)(pt_frame*NBPG);

		//add the above table to page directory
		ptr1->pd_pres = 1;
		ptr1->pd_write = 1;
		ptr1->pd_user = 0;
		ptr1->pd_pwt = 0;
		ptr1->pd_pcd = 0;
		ptr1->pd_acc = 0;
		ptr1->pd_mbz = 0;
		ptr1->pd_fmb = 0;
		ptr1->pd_global = 0;
		ptr1->pd_avail = 0;
		ptr1->pd_base = pt_frame;

		//kprintf("\nget_frm return frame %d. To be page table for process %s",pt_frame, proctab[currpid].pname);

	}
	//add entry to page table
	ptr += pt_offset;
	ptr->pt_pres = 1;
	ptr->pt_write = 1;
	ptr->pt_user = 0;
	ptr->pt_pwt = 0;
	ptr->pt_pcd = 0;
	ptr->pt_acc = 0;
	ptr->pt_dirty = 0;
	ptr->pt_mbz = 0;
	ptr->pt_global = 0;
	ptr->pt_avail = 0;

	  //getting a free frame an setting the frame mappings
  int free_frm;
  if(ni_page_table[backing_store_page-total_bs_left] != -1) // if backing store is already mapped then we share the frame
	{
		free_frm = ni_page_table[backing_store_page-total_bs_left];
		//kprintf("\nIN NI frm = %d, ni = %d\n",free_frm, ni_page_table[backing_store_page-total_bs_left]);
		frm_map[free_frm-FRAME0].fr_refcnt++;
		frm_tab[free_frm-FRAME0].refcnt++;

		//adding this vpno and pid to the shared frame map list
		fr_map_t *map = (fr_map_t *)getmem(sizeof(fr_map_t));
		map->fr_pid = currpid;
		map->fr_vpno = eip;
		map->shared = NULL;

		fr_map_t *next = (fr_map_t *)getmem(sizeof(fr_map_t));
		next = &(frm_map[free_frm-FRAME0]);

		while(next->shared != NULL)
				next = next->shared;

		next->shared = map;

		//printing the list
		/*kprintf("\nSHARED VPNO: ");
		next = &(frm_map[free_frm-FRAME0]);
		while(next != NULL)
		{
			kprintf("%d -> ",next->fr_vpno);
			next = next->shared;
		}*/
	}
	else
	{
		free_frm = get_frm();
		
		frm_tab[free_frm-FRAME0].status = FRM_BS;
		frm_tab[free_frm-FRAME0].refcnt++;
		frm_tab[free_frm-FRAME0].bs = bs_id;
		frm_tab[free_frm-FRAME0].bs_page = backing_store_page;
		frm_tab[free_frm-FRAME0].bs_next = NULL;
		frm_tab[free_frm-FRAME0].fifo = NULL;
		frm_tab[free_frm-FRAME0].age = 128;
 		frm_map[free_frm-FRAME0].fr_status = FRM_MAPPED;
		frm_map[free_frm-FRAME0].fr_pid = currpid;
		frm_map[free_frm-FRAME0].fr_vpno = eip;
		frm_map[free_frm-FRAME0].fr_refcnt++;
		frm_map[free_frm-FRAME0].fr_type = FR_PAGE;
		frm_map[free_frm-FRAME0].bs_page_num = backing_store_page;

		ni_page_table[backing_store_page-total_bs_left] = free_frm;
		
		//set bs mappings
		if(bs_tab[bs_id].frm == NULL)
				  bs_tab[bs_id].frm = &frm_tab[free_frm-FRAME0];
		else
		{
			//frame_t *jump = &frm_tab[free_frm-FRAME0];
			frame_t *jump = (frame_t *)getmem(sizeof(frame_t)); 
			jump = bs_tab[bs_id].frm;
			while(jump->bs_next != NULL)
			{
				jump = jump->bs_next;
				//kprintf("\njumping\n");
			}

			jump->bs_next = &frm_tab[free_frm-FRAME0];
		}

		//adding this frame to the fifo queue
		if(fifo_head == NULL)
		{
			//queue is empty
			fifo_head = &frm_tab[free_frm-FRAME0];
			fifo_tail = fifo_head;
		}
		else
		{
			fifo_tail->fifo = &frm_tab[free_frm-FRAME0];
			fifo_tail = &frm_tab[free_frm-FRAME0];
		}
	}
	//kprintf("\nget_frm return frame %d.", free_frm);
	
  unsigned long *dst_addr = (unsigned long *)(free_frm*NBPG);

  //kprintf("\n\n Virtual page %d mapped to bs page %d, bs id %d, mapped to frame %d, %lu",eip, backing_store_page, bs_id, free_frm,dst_addr);

	/*frame_t *next = fifo_head;
	kprintf("\nFIFO : ");
	while(next != NULL)
	{
		kprintf("%d-> ",next->frame_num);
		next = next->fifo;
	}
	kprintf("\n");*/

	
   //copy page from bs to phy
   for(i = 0; i < NBPG/sizeof(unsigned long); i++)
   {
		*dst_addr = *bs_addr;
		dst_addr++;
		bs_addr++;

   }
   
	ptr->pt_base = free_frm;

	restore(ps);

	//kprintf("\nmap bs%d/page: %d to frame %d",bs_id, (backing_store_page-proctab[currpid].map[bs_id].base_page), free_frm);
  return OK;
}
Пример #26
0
Файл: getmem.c Проект: r9y9/SPTK
float *fgetmem(const int leng)
{
   return ((float *) getmem((size_t) leng, sizeof(float)));
}
Пример #27
0
static inline unsigned char pop() {
	if (s<0xff) s++;
	return getmem(0x100+s);
}
Пример #28
0
Файл: getmem.c Проект: r9y9/SPTK
real *rgetmem(const int leng)
{
   return ((real *) getmem((size_t) leng, sizeof(real)));
}
Пример #29
0
static unsigned char getaddr(int mode) {
	unsigned short ad, ad2;
	switch(mode) {
	case imp:
		cycles+=2;
		return 0;
	case imm:
		cycles+=2;
		return getmem(pc++);
	case abs:
		cycles+=4;
		ad=getmem(pc++);
		ad|=getmem(pc++)<<8;
		return getmem(ad);
	case absx:
		cycles+=4;
		ad=getmem(pc++);
		ad|=256*getmem(pc++);
		ad2=ad+x;
		if ((ad2&0xff00)!=(ad&0xff00)) cycles++;
		return getmem(ad2);
	case absy:
		cycles+=4;
		ad=getmem(pc++);
		ad|=256*getmem(pc++);
		ad2=ad+y;
		if ((ad2&0xff00)!=(ad&0xff00)) cycles++;
		return getmem(ad2);
	case zp:
		cycles+=3;
		ad=getmem(pc++);
		return getmem(ad);
	case zpx:
		cycles+=4;
		ad=getmem(pc++);
		ad+=x;
		return getmem(ad&0xff);
	case zpy:
		cycles+=4;
		ad=getmem(pc++);
		ad+=y;
		return getmem(ad&0xff);
	case indx:
		cycles+=6;
		ad=getmem(pc++);
		ad+=x;
		ad2=getmem(ad&0xff);
		ad++;
		ad2|=getmem(ad&0xff)<<8;
		return getmem(ad2);
	case indy:
		cycles+=5;
		ad=getmem(pc++);
		ad2=getmem(ad);
		ad2|=getmem((ad+1)&0xff)<<8;
		ad=ad2+y;
		if ((ad2&0xff00)!=(ad&0xff00)) cycles++;
		return getmem(ad);
	case acc:
		cycles+=2;
		return a;
	}
	return 0;
}
Пример #30
0
SYSCALL pfint()
{
  	unsigned long cr2,physical_addr;
  	virt_addr_t * vaddr;
    int vp,s,o,avail,*store,*pageth;
  	unsigned int p,q,pt;
    pd_t *pd;
    pt_t *new_pt;
    STATWORD ps;
	// Disable interrupts
    disable(ps);
    if(GDB)
      kprintf("\n*************pfint is running!************\n");
  // Get the faulted address. The processor loads the CR2 register
  // with the 32-bit address that generated the exception.
  /* 1. Get the faulted address. */
    cr2 = read_cr2();
    vaddr = (virt_addr_t *)(&cr2); 
    if(GDB)
      kprintf("&cr2=%x, cr2=%x, &vaddr=%x, vaddr=%x\n",&cr2,cr2,&vaddr,vaddr);
  /* 2. Let 'vp' be the virtual page number of the page containing of the faulted address */
    vp = a2pno(cr2);
    if(GDB)
      kprintf("vp=%d,\n",vp);
  /* 3. Let pd point to the current page directory. */
    pd = proctab[currpid].pdbr;
    if(GDB)
      kprintf("pd=%x,\n",pd);
  /* 4. Check that a is a legal address (i.e., it has been mapped). 
     If it is not, print an error message and kill the process. */  
    pageth = getmem( sizeof(int *) );
    store = getmem( sizeof(int *) );
    if( SYSERR == bsm_lookup(currpid, vp, store, pageth)){
      kprintf("ERROR: This virtual address hasn't been mapped!\n");
      kill(currpid);
    }
  /* 5. Let p be the upper ten bits of a. [p represents page dirctory offset] */
  /* 6. Let q be the bits [21:12] of a. [p represents page table offset.]
  /* 7.1 Let pt point to the pth page table.*/
    p = vaddr->pd_offset;
    q = vaddr->pt_offset;
    pt = vaddr->pg_offset;
    if(GDB)
      kprintf("p=%d,q=%d,pt=%d\n",p,q,pt);
  /* 7.2  If the pth page table does not exist obtain a frame for it and initialize it. */
    if(pd[p].pd_pres != 1){
      if(GDB)
        kprintf("**obtain a frame for the new page table. \n");
      avail = get_frm();  //get the id of a new frame from frm_tab[];
      if (avail == -1) {
            if(GDB)
              kprintf("Could not create page table!\n");
            restore(ps);
            return SYSERR;
      }
      //initialize frame[avail], update the process_id and frame_type of this frame.
      init_frm(avail, currpid, FR_TBL);
      frm_tab[avail].fr_upper_t = pa2frid((unsigned long) pd);
      if(GDB)
        kprintf("upper page table @frame[%d]  pd=%x, a2pno(pd)=%d\n",frm_tab[avail].fr_upper_t, pd, a2pno((unsigned long) pd));
      new_pt = frid2pa(avail);
      init_pt(new_pt);
      //update this page_table_entry in the page_directory.
      pd[p].pd_pres = 1;
      pd[p].pd_write = 1;
      pd[p].pd_user = 0; // not sure about the usage;
      pd[p].pd_pwt = 0;
      pd[p].pd_pcd = 0;
      pd[p].pd_acc = 0;
      pd[p].pd_mbz = 0;
      pd[p].pd_fmb = 0;
      pd[p].pd_global = 0;
      pd[p].pd_avail = 0; // not in use right now.
      pd[p].pd_base = a2pno((unsigned long) new_pt);  /* location of page table */
      if(GDB)
        kprintf("New page_table(%x)@frame[%d] updated in page_directory[%d]@(frame[%d])\n",
        new_pt, avail, p, frm_tab[avail].fr_upper_t);
      if(GDB)
        kprintf("q=%d, new_pt[q]=%x, new_pt=%x, pd[p].pd_base=%d\n",
        q, new_pt[q], new_pt, pd[p].pd_base);
    }
    //if the page table has already existed, just need to refcnt++;
    else
    {
      int avail = pd[p].pd_base -1024;
      frm_tab[avail].fr_refcnt++;
      if(GDB)
        kprintf("frm_tab[%d].fr_refcnt = %d, frame_type: %d\n",avail, frm_tab[avail].fr_refcnt, frm_tab[avail].fr_type);
    }
/* 8.1 Using the backing store map, find the store s and page offset o which correspond to vp. */
    //already saved in 'store' and 'pageth'
    s = *store;
    o = *pageth;
/* 8.2 In the inverted page table increment the reference count of the frame which holds pt. 
   This indicates that one more of pt's entries is marked "present." */
    avail = find_frm(currpid,vp);
    if (avail == -1)
    {
      if(GDB)
        kprintf("allocating a page for the page fault\n");

      avail = get_frm();
      if(avail == -1)
      {
        if(GDB)
          kprintf("ATTENTION! Frames full. ###Replacement NEEDED!###\n");
        int frame_number = proctab[currpid].nframes-1;
        int frame_id = proc_frames[currpid][0];
        //update_proc_frames(pid,frame_number);
        int i;
        for (i = 0; i+1 < frame_number; ++i)
        {
          proc_frames[currpid][i] = proc_frames[currpid][i+1];
        }
        proctab[currpid].nframes = frame_number;

        int pid = frm_tab[frame_id].fr_pid;
        int upper_id = frm_tab[frame_id].fr_upper_t;    
        vp = frm_tab[frame_id].fr_vpno;
        if(GDB)
          kprintf("currpid=%d, frame[%d].pid=%d .vpno=%d, upper_frame[%d].ref=%d\n",currpid,frame_id,pid,vp,upper_id,frm_tab[upper_id].fr_refcnt);
        p = vp>>10;
        q = vp &0x003ff;        
        new_pt = vp2pa(pd[p].pd_base);
        new_pt[q].pt_pres  = 0;
        new_pt[q].pt_write = 1;
        new_pt[q].pt_base  = 0;
        if(GDB)
          kprintf("pd_offset=%d, pt_offset=%d, pt_dirty=%d\n",p,q,new_pt[q].pt_dirty);
        if(new_pt[q].pt_dirty == 1)
        {
          //write back and 
          pageth = getmem( sizeof(int *) );
          store = getmem( sizeof(int *) );
          if( SYSERR == bsm_lookup(currpid, vp, store, pageth)){
            kprintf("ERROR: This virtual address hasn't been mapped!\n");
            kill(currpid);
          }
          if(GDB)
            kprintf("maping found: {pid: %d, vpno: %d, store: %d, pageth: %d}\n",currpid,vp,*store,*pageth);
          write_bs((char *)new_pt, *store, *pageth);
        }
        init_pt(new_pt);
        reset_frm(frame_id);

        frm_tab[upper_id].fr_refcnt -= 2; //it is 2, not 1.
        if(frm_tab[upper_id].fr_refcnt <= 0){
          //mark the appropriate entry in pd as being not present, and free pt.
        }

        //invalidate the TLB entry for the page vp using the invlpg instruction
        if(pid == currpid) {
          set_PDBR(currpid);
        }
      }
      else
      {
        init_frm(avail, currpid, FR_PAGE);
        frm_tab[avail].fr_upper_t = pd[p].pd_base-FRAME0;
        if(GDB)
          kprintf("upper page table @frame[%d]\n",frm_tab[avail].fr_upper_t);
        frm_tab[avail].fr_vpno = vp;
        

        int counter =  proctab[currpid].nframes;      
        proc_frames[currpid][counter] = frm_tab[avail].fr_id;
        proctab[currpid].nframes++;
        if(GDB)
          kprintf("proc_frames[%d][%d] = frame[%d]\n",currpid,counter,avail);


        // Add this frame to head of the frame list within the bs of this process
        //(frm_tab[avail].bs_next)->fr_vpno
        //, proctab[currpid].bsmap[s].frames->bs_next
        if(GDB)
          kprintf("&frm_tab[avail].bs_next = %x\n",frm_tab[avail].bs_next, &frm_tab[avail].bs_next);
        if(GDB)
          kprintf("proctab[%d].bsmap[%d].frames = %x, ->vpno=%d, ->bs_next=%x\n",currpid, s, proctab[currpid].bsmap[s].frames, proctab[currpid].bsmap[s].frames->fr_vpno, proctab[currpid].bsmap[s].frames->bs_next);
        frm_tab[avail].bs_next = getmem(sizeof(fr_map_t *));
        frm_tab[avail].bs_next =  proctab[currpid].bsmap[s].frames;
        proctab[currpid].bsmap[s].frames = &frm_tab[avail];
        fr_map_t *frame = proctab[currpid].bsmap[s].frames;
        int i = frame->fr_vpno;
        if(GDB)
          kprintf("i = %d\n",i);
        if(GDB)
          kprintf("~~~frame[%d] linked to frame[%d]\n", avail, frame->bs_next==NULL?-1:frame->bs_next->fr_id);
        if(GDB)
          kprintf("frame[%d].bs_next = %x, &**=%x\n",avail,frm_tab[avail].bs_next, &frm_tab[avail].bs_next);
        if(GDB)
          kprintf("proctab[%d].bsmap[%d].frames = %x, ->vpno=%d, ->bs_next=%x\n",currpid, s, proctab[currpid].bsmap[s].frames, proctab[currpid].bsmap[s].frames->fr_vpno, proctab[currpid].bsmap[s].frames->bs_next);

        
        if(GDB)
          kprintf("Mapping frame[%d](ppno[%d]) to {pid[%d], vpno[%d]} -> {bs[%d],offset:%d}\n",
          avail,frid2vpno(avail),currpid,vp,s,o);

        physical_addr = frid2pa(avail);
        read_bs(physical_addr,s,o);
        if(GDB)
          kprintf("copied from bs[%d]:offset[%d] to vp[%d]@(%x)\n",s,o,vp,vp2pa(vp));
      }
    }