自学教程：C++ vinit函数代码示例

double daxpy(size_t N, size_t iterations = 1){        value_type* a = new value_type[N];    value_type* b = new value_type[N];    double c = 3;        vinit(N, a);    vinit(N, b);        std::vector<double> times;    for(size_t i = 0; i < iterations; ++i){                auto start = std::chrono::steady_clock::now();        for(size_t i = 0; i < N; ++i){            b[i] += a[i]*c;        }        auto end = std::chrono::steady_clock::now();                auto diff = end - start;        times.push_back(std::chrono::duration<double, std::milli> (diff).count()); //save time in ms for each iteration    }        delete [] a;    delete [] b;        double tmin = *(std::min_element(times.begin(), times.end()));    double tavg = average_time(times);        // check to see if nothing happened during run to invalidate the times    if(variance(tavg, times) > max_variance){        std::cerr << "clike kernel 'daxpy': Time deviation too large! /n";    }        return tavg;}

/* initialise new fire particle */static void setnewpart(firestruct * fs, part * p){    float a, vi[3], *c;    p->age = 0;    a = vrnd() * M_PI * 2.0;    vinit(vi, sin(a) * fs->eject_r * vrnd(), 0.15, cos(a) * fs->eject_r * vrnd());    vinit(p->p[0], vi[0] + vrnd() * fs->ridtri, vi[1] + vrnd() * fs->ridtri, vi[2] + vrnd() * fs->ridtri);    vinit(p->p[1], vi[0] + vrnd() * fs->ridtri, vi[1] + vrnd() * fs->ridtri, vi[2] + vrnd() * fs->ridtri);    vinit(p->p[2], vi[0] + vrnd() * fs->ridtri, vi[1] + vrnd() * fs->ridtri, vi[2] + vrnd() * fs->ridtri);    vinit(p->v, vi[0] * fs->eject_vl / (fs->eject_r / 2),	  vrnd() * fs->eject_vy + fs->eject_vy / 2,	  vi[2] * fs->eject_vl / (fs->eject_r / 2));    c = partcol1;    vinit4(p->c[0], c[0] * ((1.0 - RIDCOL) + vrnd() * RIDCOL),	   c[1] * ((1.0 - RIDCOL) + vrnd() * RIDCOL),	   c[2] * ((1.0 - RIDCOL) + vrnd() * RIDCOL), 1.0);    vinit4(p->c[1], c[0] * ((1.0 - RIDCOL) + vrnd() * RIDCOL),	   c[1] * ((1.0 - RIDCOL) + vrnd() * RIDCOL),	   c[2] * ((1.0 - RIDCOL) + vrnd() * RIDCOL), 1.0);    vinit4(p->c[2], c[0] * ((1.0 - RIDCOL) + vrnd() * RIDCOL),	   c[1] * ((1.0 - RIDCOL) + vrnd() * RIDCOL),	   c[2] * ((1.0 - RIDCOL) + vrnd() * RIDCOL), 1.0);}

double gemv2(size_t N, size_t iterations = 1){        blaze::DynamicMatrix<value_type, blaze::rowMajor> A(N, N);    blaze::DynamicVector<value_type, blaze::columnVector> a(N), b(N);    value_type c = 3, d = 5;        vinit(N, a);    vinit(N, b);    minit(N, A);        std::vector<double> times;    for(size_t i = 0; i < iterations; ++i){                auto start = std::chrono::steady_clock::now();        b = c * blaze::trans(A) * a + d * b;        auto end = std::chrono::steady_clock::now();                auto diff = end - start;        times.push_back(std::chrono::duration<double, std::milli> (diff).count()); //save time in ms for each iteration    }        double tmin = *(std::min_element(times.begin(), times.end()));    double tavg = average_time(times);        // check to see if anything happened during run to invalidate the times    if(variance(tavg, times) > max_variance){        std::cerr << "blaze kernel 'gemv2': Time deviation too large! /n";    }        return tavg;    }

double vecvecadd(size_t N, size_t iterations = 1) {    Eigen::VectorXd a(N), b(N), c(N);    vinit(a.rows(), a);    vinit(b.rows(), b);    std::vector<double> times;    for(size_t i = 0; i < iterations; ++i) {        auto start = std::chrono::steady_clock::now();        c = a + b;        auto end = std::chrono::steady_clock::now();        auto diff = end - start;        times.push_back(std::chrono::duration<double, std::milli> (diff).count()); //save time in ms for each iteration    }    double tmin = *(std::min_element(times.begin(), times.end()));    double tavg = average_time(times);    // check to see if nothing happened during run to invalidate the times    if(variance(tavg, times) > max_variance) {        std::cerr << "eigen kernel 'vecvecadd': Time deviation too large! /n";    }    return tavg;}

double dotproduct(size_t N, size_t iterations = 1){        blaze::DynamicVector<value_type> a(N), b(N);    double c = 0;        vinit(a.size(), a);    vinit(b.size(), b);        std::vector<double> times;    for(size_t i = 0; i < iterations; ++i){                auto start = std::chrono::steady_clock::now();        c = (a, b);        auto end = std::chrono::steady_clock::now();                auto diff = end - start;        times.push_back(std::chrono::duration<double, std::milli> (diff).count()); //save time in ms for each iteration    }        double tmin = *(std::min_element(times.begin(), times.end()));    double tavg = average_time(times);        // check to see if anything happened during run to invalidate the times    if(variance(tavg, times) > max_variance){        std::cerr << "blaze kernel 'dotproduct': Time deviation too large! /n";    }        return tavg;    }

int mainCPU(int argc, char **argv) {	amiSmallptCPU = 1;	//fprintf(stderr, "Usage: %s/n", argv[0]);	//fprintf(stderr, "Usage: %s <window width> <window height> <scene file>/n", argv[0]);	/*	if (argc == 4) {		width = atoi(argv[1]);		height = atoi(argv[2]);		ReadScene(argv[3]);	} else if (argc == 1) {	*/		spheres = CornellSpheres;		sphereCount = sizeof(CornellSpheres) / sizeof(Sphere);		vinit(camera.orig, 50.f, 45.f, 205.6f);		vinit(camera.target, 50.f, 45 - 0.042612f, 204.6);/*	} else		exit(-1);*/	UpdateCamera();	/*------------------------------------------------------------------------*/	AllocateBuffers();	/*------------------------------------------------------------------------*/	InitGlut(argc, argv, "SmallPT CPU V1.6 (Written by David Bucciarelli)");    glutMainLoop( );	return 0;}

static void setnewpart(part *p){  float a,v[3],*c;  p->age=0;  a=vrnd()*3.14159265359*2.0;  vinit(v,sin(a)*eject_r*vrnd(),0.15,cos(a)*eject_r*vrnd());  vinit(p->p[0],v[0]+vrnd()*ridtri,v[1]+vrnd()*ridtri,v[2]+vrnd()*ridtri);  vinit(p->p[1],v[0]+vrnd()*ridtri,v[1]+vrnd()*ridtri,v[2]+vrnd()*ridtri);  vinit(p->p[2],v[0]+vrnd()*ridtri,v[1]+vrnd()*ridtri,v[2]+vrnd()*ridtri);  vinit(p->v,v[0]*eject_vl/(eject_r/2),vrnd()*eject_vy+eject_vy/2,v[2]*eject_vl/(eject_r/2));  c=blu;  vinit4(p->c[0],c[0]*((1.0-RIDCOL)+vrnd()*RIDCOL),	 c[1]*((1.0-RIDCOL)+vrnd()*RIDCOL),	 c[2]*((1.0-RIDCOL)+vrnd()*RIDCOL),	 1.0);  vinit4(p->c[1],c[0]*((1.0-RIDCOL)+vrnd()*RIDCOL),	 c[1]*((1.0-RIDCOL)+vrnd()*RIDCOL),	 c[2]*((1.0-RIDCOL)+vrnd()*RIDCOL),	 1.0);  vinit4(p->c[2],c[0]*((1.0-RIDCOL)+vrnd()*RIDCOL),	 c[1]*((1.0-RIDCOL)+vrnd()*RIDCOL),	 c[2]*((1.0-RIDCOL)+vrnd()*RIDCOL),	 1.0);}

static Bool Init(ModeInfo * mi){    int i;    firestruct *fs = &fire[MI_SCREEN(mi)];    /* default settings */    fs->eject_r = 0.1 + NRAND(10) * 0.03;    fs->dt = 0.015;    fs->eject_vy = 4;    fs->eject_vl = 1;    fs->ridtri = 0.1 + NRAND(10) * 0.005;    fs->maxage = 1.0 / fs->dt;    vinit(fs->obs, DEF_OBS[0], DEF_OBS[1], DEF_OBS[2]);    fs->v = 0.0;    fs->alpha = DEF_ALPHA;    fs->beta = DEF_BETA;    /* initialise texture stuff */    if (do_texture)    	inittextures(mi);    else    {	fs->ttexture = (XImage*) NULL;	fs->gtexture = (XImage*) NULL;    }    if (MI_IS_DEBUG(mi)) {	(void) fprintf(stderr,		       "%s:/n/tnum_part=%d/n/ttrees=%d/n/tfog=%s/n/tshadows=%s/n/teject_r=%.3f/n/tridtri=%.3f/n",		       MI_NAME(mi),		       fs->np,		       fs->num_trees,		       fs->fog ? "on" : "off",		       fs->shadows ? "on" : "off",		       fs->eject_r, fs->ridtri);    }    /* initialise particles and trees */    for (i = 0; i < fs->np; i++) {	setnewpart(fs, &(fs->p[i]));    }    if (fs->num_trees)	if (!inittree(mi)) {		return False;	}    /* if no fire particles then initialise rain particles */    if (!fs->np)    {	vinit(fs->min,-7.0f,-0.2f,-7.0f);  	vinit(fs->max,7.0f,8.0f,7.0f);    	for (i = 0; i < NUMPART; i++) {	    setnewrain(fs, &(fs->r[i]));    	}    }        return True;}

// gcopnames creates opnames.h from go.h.// It finds the OXXX enum, pulls out all the constants// from OXXX to OEND, and writes a table mapping// op to string.voidgcopnames(char *dir, char *file){	char *p, *q;	int i, j, end;	Buf in, b, out;	Vec lines, fields;		binit(&in);	binit(&b);	binit(&out);	vinit(&lines);	vinit(&fields);		bwritestr(&out, bprintf(&b, "// auto generated by go tool dist/n"));	bwritestr(&out, bprintf(&b, "static char *opnames[] = {/n"));	readfile(&in, bprintf(&b, "%s/go.h", dir));	splitlines(&lines, bstr(&in));	i = 0;	while(i<lines.len && !contains(lines.p[i], "OXXX"))		i++;	end = 0;	for(; i<lines.len && !end; i++) {		p = xstrstr(lines.p[i], "//");		if(p != nil)			*p = '/0';		end = contains(lines.p[i], "OEND");		splitfields(&fields, lines.p[i]);		for(j=0; j<fields.len; j++) {			q = fields.p[j];			if(*q == 'O')				q++;			p = q+xstrlen(q)-1;			if(*p == ',')				*p = '/0';			bwritestr(&out, bprintf(&b, "	[O%s] = /"%s/",/n", q, q));		}	}		bwritestr(&out, bprintf(&b, "};/n"));	writefile(&out, file, 0);	bfree(&in);	bfree(&b);	bfree(&out);	vfree(&lines);	vfree(&fields);}

double smatsvecmult(size_t N, size_t iterations = 1) {        mtl::compressed2D<value_type> a(N, N);    mtl::dense_vector<value_type> b(N), c(N); // sparse not fully implemented yet        sminit(N, a);    vinit(N, b);        std::vector<double> times;    for(size_t i = 0; i < iterations; ++i){                auto start = std::chrono::steady_clock::now();        c = a * b;        auto end = std::chrono::steady_clock::now();                auto diff = end - start;        times.push_back(std::chrono::duration<double, std::milli> (diff).count()); //save time in ms for each iteration    }        double tmin = *(std::min_element(times.begin(), times.end()));    double tavg = average_time(times);        // check to see if nothing happened during run to invalidate the times    if(variance(tavg, times) > max_variance){        std::cerr << "mtl kernel 'smatsvecmult': Time deviation too large! /n";    }        return tavg;    }

ENTRYPOINT void change_fire(ModeInfo * mi){    firestruct *fs = &fire[MI_SCREEN(mi)];    if (!fs->glx_context)	return;    glXMakeCurrent(MI_DISPLAY(mi), MI_WINDOW(mi), *(fs->glx_context));    /* if available, randomly change some values */    if (do_fog)	fs->fog = LRAND() & 1;    if (do_shadows)	fs->shadows = LRAND() & 1;    /* reset observer position */    frame = 0;    vinit(fs->obs, DEF_OBS[0], DEF_OBS[1], DEF_OBS[2]);    fs->v = 0.0;    /* particle randomisation */    fs->eject_r = 0.1 + NRAND(10) * 0.03;    fs->ridtri = 0.1 + NRAND(10) * 0.005;    if (MI_IS_DEBUG(mi)) {	(void) fprintf(stderr,		       "%s:/n/tnum_part=%d/n/ttrees=%d/n/tfog=%s/n/tshadows=%s/n/teject_r=%.3f/n/tridtri=%.3f/n",		       MI_NAME(mi),		       fs->np,		       fs->num_trees,		       fs->fog ? "on" : "off",		       fs->shadows ? "on" : "off",		       fs->eject_r, fs->ridtri);    }}

void vbgfx_set_res(vga_card* v, int64_t w, int64_t h, uint8_t bpp){  if(!v) return;  if(!v->data[0]) return;  if(w * h > 1440000) return;  uint32_t iobase = v->data[0];  outw(iobase + VBGFX_IO_INDEX, VBGFX_INDEX_ENABLE);  outw(iobase + VBGFX_IO_DATA, 0); //disable VBE extensions  //write resolution  outw(iobase + VBGFX_IO_INDEX, VBGFX_INDEX_XRES);  outw(iobase + VBGFX_IO_DATA, w);  outw(iobase + VBGFX_IO_INDEX, VBGFX_INDEX_YRES);  outw(iobase + VBGFX_IO_DATA, h);  //write bpp  outw(iobase + VBGFX_IO_INDEX, VBGFX_INDEX_BPP);  outw(iobase + VBGFX_IO_DATA, bpp);  //reset video module  vdestroy();  //enable VBE extensions and LFB  outw(iobase + VBGFX_IO_INDEX, VBGFX_INDEX_ENABLE);  outw(iobase + VBGFX_IO_DATA, 1 | 0x40);  //init video module  int64_t width, height, bppix;  uint32_t lfb_addr = pci_config_read_dword(v->bus, v->slot, 0, 0x10) & ~0xF;  outw(iobase + VBGFX_IO_INDEX, VBGFX_INDEX_XRES);  width = inw(iobase + VBGFX_IO_DATA);  outw(iobase + VBGFX_IO_INDEX, VBGFX_INDEX_YRES);  height = inw(iobase + VBGFX_IO_DATA);  outw(iobase + VBGFX_IO_INDEX, VBGFX_INDEX_BPP);  bppix = inl(iobase + VBGFX_IO_DATA);  vinit(width, height, bppix, w * 4, lfb_addr);}

void initBitlash(unsigned long baud) {#if defined(TINY_BUILD)	beginSerial(9600);#else	beginSerial(baud);#endif#if defined(ARM_BUILD)	eeinit();#endif	initTaskList();	vinit();	displayBanner();#if !defined(TINY_BUILD)	// Run the script named "startup" if there is one	strncpy_P(lbuf, getmsg(M_startup), STRVALLEN);	// get the name "startup" in our cmd buf	//if (findKey(lbuf) >= 0) doCommand(lbuf);		// look it up.  exists?  call it.	if (findscript(lbuf)) doCommand(lbuf);			// look it up.  exists?  call it.#endif	initlbuf();}

double rmajordmvmult(size_t N, size_t iterations = 1){        Eigen::Matrix<value_type, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor> A(N, N);    Eigen::Matrix<value_type, Eigen::Dynamic, 1> b(N), c(N);        minit(N, A);    vinit(N, b);    std::vector<double> times;    for(size_t i = 0; i < iterations; ++i){                auto start = std::chrono::steady_clock::now();        c.noalias() = A * b;        auto end = std::chrono::steady_clock::now();                auto diff = end - start;        times.push_back(std::chrono::duration<double, std::milli> (diff).count()); //save time in ms for each iteration    }        double tmin = *(std::min_element(times.begin(), times.end()));    double tavg = average_time(times);      // check to see if nothing happened during run to invalidate the times    if(variance(tavg, times) > max_variance){        std::cerr << "eigen kernel 'rmajordmvmult': Time deviation too large! /n";    }        return tavg;    }

// xremoveall removes the file or directory tree rooted at p.voidxremoveall(char *p){	int i;	Buf b;	Vec dir;	binit(&b);	vinit(&dir);	if(isdir(p)) {		xreaddir(&dir, p);		for(i=0; i<dir.len; i++) {			bprintf(&b, "%s/%s", p, dir.p[i]);			xremoveall(bstr(&b));		}		if(vflag > 2)			xprintf("rm %s/n", p);		rmdir(p);	} else {		if(vflag > 2)			xprintf("rm %s/n", p);		unlink(p);	}		bfree(&b);	vfree(&dir);	}

double dmatvecmult(size_t N, size_t iterations = 1) {        boost::numeric::ublas::matrix<double> a(N, N);    boost::numeric::ublas::vector<double> b(N), c(N);        minit(a.size1(), a);    vinit(b.size(), b);        std::vector<double> times;    for(size_t i = 0; i < iterations; ++i){                auto start = std::chrono::steady_clock::now();        boost::numeric::ublas::axpy_prod(a, b, c, false);        auto end = std::chrono::steady_clock::now();                auto diff = end - start;        times.push_back(std::chrono::duration<double, std::milli> (diff).count()); //save time in ms for each iteration    }        double tmin = *(std::min_element(times.begin(), times.end()));    double tavg = average_time(times);    /*     // check to see if nothing happened during rum to invalidate the times     if(tmin*(1.0 + deviation*0.01) < tavg){     std::cerr << "uBLAS kernel 'dmatvecmult': Time deviation too large!!!" << std::endl;     }     */    return tavg;    }

// vfree frees the storage associated with the vector.voidvfree(Vec *v){	vreset(v);	xfree(v->p);	vinit(v);}

double cmajordmvmult(size_t N, size_t iterations = 1){    typedef mtl::tag::col_major col_major;    typedef mtl::mat::parameters<col_major> parameters;    typedef mtl::dense2D<value_type, parameters> dense2D;    typedef mtl::dense_vector<value_type> dense_vector;        dense2D A(N, N);    dense_vector b(N), c(N);        minit(N, A);    vinit(N, b);        std::vector<double> times;    for(size_t i = 0; i < iterations; ++i){                auto start = std::chrono::steady_clock::now();        c = A * b;        auto end = std::chrono::steady_clock::now();                auto diff = end - start;        times.push_back(std::chrono::duration<double, std::milli> (diff).count()); //save time in ms for each iteration    }        double tmin = *(std::min_element(times.begin(), times.end()));    double tavg = average_time(times);     // check to see if nothing happened during run to invalidate the times    if(variance(tavg, times) > max_variance){        std::cerr << "mtl kernel 'cmajordmvmult': Time deviation too large! /n";    }    return tavg;    }

double vecvscalaradd(size_t N, size_t iterations = 1) {        boost::numeric::ublas::vector<double> a(N), b(N);    double c = 3;        vinit(b.size(), b);        std::vector<double> times;    for(size_t i = 0; i < iterations; ++i){                auto start = std::chrono::steady_clock::now();        noalias(a) = b + boost::numeric::ublas::scalar_vector<double>(N, c);        auto end = std::chrono::steady_clock::now();                auto diff = end - start;        times.push_back(std::chrono::duration<double, std::milli> (diff).count()); //save time in ms for each iteration    }        double tmin = *(std::min_element(times.begin(), times.end()));    double tavg = average_time(times);    /*     // check to see if nothing happened during rum to invalidate the times     if(tmin*(1.0 + deviation*0.01) < tavg){     std::cerr << "uBLAS kernel 'vecscalaradd': Time deviation too large!!!" << std::endl;     }     */    return tavg;    }

double vecscalarmult(size_t N, size_t iterations = 1) {        boost::numeric::ublas::vector<value_type> a(N), b(N);    value_type c = 3;        vinit(a.size(), a);        std::vector<double> times;    for(size_t i = 0; i < iterations; ++i){                auto start = std::chrono::steady_clock::now();        noalias(a) = b * c;        auto end = std::chrono::steady_clock::now();                auto diff = end - start;        times.push_back(std::chrono::duration<double, std::milli> (diff).count()); //save time in ms for each iteration    }        double tmin = *(std::min_element(times.begin(), times.end()));    double tavg = average_time(times);        // check to see if nothing happened during run to invalidate the times    if(variance(tavg, times) > max_variance){        std::cerr << "boost kernel 'vecscalarmult': Time deviation too large! /n";    }        return tavg;    }

void amdrv100init(uint8_t bus, uint8_t slot){  printf("amd_rv100: init on bus:slot %x:%x/n", bus, slot);  uint16_t vendor = pci_config_read_word(bus, slot, 0, 0);  if(vendor == 0xFFFF)  {    puts("amd_rv100: init failed: device not found on specified bus:slot/n");    return;  }  uint16_t device = pci_config_read_word(bus, slot, 0, 2);  if(device != 0x4c59)  {    puts("amd_rv100: init failed: device is not compatible/n");    return;  }  uint32_t fbaddr = pci_config_read_dword(bus, slot, 0, 0x10) & ~0xF;  uint32_t port = pci_config_read_dword(bus, slot, 0, 0x14) & ~0x3;  printf("amd_rv100: framebuffer addr: 0x%x port: 0x%x/n", fbaddr, port);  vga_card* v = graphics_add_card();  if(!v) return;  v->bus = bus;  v->slot = slot;  v->data[0] = fbaddr;  v->data[1] = port;  pci_config_write_byte(bus, slot, 0, 0x3d, 1);  pci_config_write_byte(bus, slot, 0, 0x3c, 11);  vdestroy();  vinit(1024, 768, 32, 1024 * 4, fbaddr);  printf("amd_rv100: finished./n");}

/////////////	Parse and interpret a stream, and return its value////	This is used in doCommand to execute a passed-in or collected text command,// in domacrocommand() when a macro/function is called from within a parse stream,//	and in runBackgroundTasks to kick off the background run.////numvar execscript(byte scripttype, numvar scriptaddress, char *scriptname) {	// save parse context	parsepoint fetchmark;	markparsepoint(&fetchmark);	byte thesym = sym;	vpush(symval);	// if this is the first stream context in this invocation,	// set up our error recovery point and init the value stack	// otherwise we skip this to allow nested execution calls 	// to properly return to top	//	if (fetchtype == SCRIPT_NONE) {		// Exceptions come here via longjmp; see bitlash-error.c		switch(setjmp(env)) {			case 0: break;			case X_EXIT: {				// POLICY: Stop all background tasks on any error				//				// It is not possible to be certain that continuing here will work.				// Not all errors leave the interpreter in a working state.  Though most do.				// The conservative/deterministic choice is to stop all background tasks				// and drop the user back to the command prompt.				//				// On the other hand, you may find this inconvenient in your application, 				// and may be happy taking the risk of continuing.				//				// In which case, comment out this line and proceed with caution.				//					// TODO: if the macro "onerror" exists, call it here instead.  Let it "stop *".				//				// -br				//				initTaskList();		// stop all pending tasks#ifdef SOFTWARE_SERIAL_TX				resetOutput();		// clean up print module#endif				// Other cleanups here				vinit();			// initialize the expression stack				fetchtype = SCRIPT_NONE;	// reset parse context				fetchptr = 0L;				// reset parse location				// sd_up = 0;				// TODO: reset file system				return (numvar) -1;			}							// X_EXIT case		}								// switch	}	initparsepoint(scripttype, scriptaddress, scriptname);	getsym();	// interpret the function text and collect its result	numvar ret = getstatementlist();	returntoparsepoint(&fetchmark, 1);		// now where were we?	sym = thesym;	symval = vpop();	return ret;}

/* calculate observer position : modified only if trackmouse is used */static void calcposobs(firestruct * fs){    fs->dir[0] = sin(fs->alpha * M_PI / 180.0);    fs->dir[2] =	cos(fs->alpha * M_PI / 180.0) * sin(fs->beta * M_PI / 180.0);    fs->dir[1] = cos(fs->beta * M_PI / 180.0);    fs->obs[0] += fs->v * fs->dir[0];    fs->obs[1] += fs->v * fs->dir[1];    fs->obs[2] += fs->v * fs->dir[2];    if (!fs->np)    {    	vinit(fs->min,fs->obs[0]-7.0f,-0.2f,fs->obs[2]-7.0f);    	vinit(fs->max,fs->obs[0]+7.0f,8.0f,fs->obs[2]+7.0f);    }}

/* initialise new rain particle */static void setnewrain(firestruct * fs, rain * r){    r->age=0.0f;    vinit(r->acc,0.0f,-0.98f,0.0f);    vinit(r->vel,0.0f,0.0f,0.0f);    r->partLength=0.2f;    vinit(r->oldpos,fs->min[0]+(fs->max[0]-fs->min[0])*vrnd(),                    fs->max[1]+0.2f*fs->max[1]*vrnd(),                    fs->min[2]+(fs->max[2]-fs->min[2])*vrnd());    vequ(r->pos,r->oldpos);    vadds(r->oldpos,-(r->partLength),r->vel);    r->pos[1]=(fs->max[1]-fs->min[1])*vrnd()+fs->min[1];    r->oldpos[1]=r->pos[1]-r->partLength*r->vel[1];}

// Initialize "last" global variable for new command line and get first symbol.  Return status.int parsebegin(Parse *newp,char *clp,int termch) {	last = newp;	last->p_clp = clp;	last->p_termch = termch;	last->p_sym = s_any;#if VDebug	vinit(&last->p_tok,"parsebegin");#else	vinit(&last->p_tok);#endif	last->p_vgarbp = vgarbp;#if MMDEBUG & DEBUG_VALUEfprintf(logfile,"parsebegin(): saved garbage pointer %.8x/n",(uint) vgarbp);#endif	(void) getsym();	return rc.status;	}

void UpdateRenderingCPU(void) {	double startTime = WallClockTime();	const float invWidth = 1.f / width;	const float invHeight = 1.f / height;	int x, y;	for (y = 0; y < height; y++) { /* Loop over image rows */		for (x = 0; x < width; x++) { /* Loop cols */			const int i = (height - y - 1) * width + x;			const int i2 = 2 * i;			const float r1 = GetRandom(&seeds[i2], &seeds[i2 + 1]) - .5f;			const float r2 = GetRandom(&seeds[i2], &seeds[i2 + 1]) - .5f;			const float kcx = (x + r1) * invWidth - .5f;			const float kcy = (y + r2) * invHeight - .5f;			Vec rdir;			vinit(rdir,				camera.x.x * kcx + camera.y.x * kcy + camera.dir.x,				camera.x.y * kcx + camera.y.y * kcy + camera.dir.y,				camera.x.z * kcx + camera.y.z * kcy + camera.dir.z);			Vec rorig;			vsmul(rorig, 0.1f, rdir);			vadd(rorig, rorig, camera.orig)			vnorm(rdir);			const Ray ray = {rorig, rdir};			Vec r;			RadiancePathTracing(spheres, sphereCount, &ray,					&seeds[i2], &seeds[i2 + 1], &r);			if (currentSample == 0)				colors[i] = r;			else {				const float k1 = currentSample;				const float k2 = 1.f / (k1 + 1.f);				colors[i].x = (colors[i].x * k1 + r.x) * k2;				colors[i].y = (colors[i].y * k1 + r.y) * k2;				colors[i].z = (colors[i].z * k1 + r.z) * k2;			}			pixels[y * width + x] = toInt(colors[i].x) |					(toInt(colors[i].y) << 8) |					(toInt(colors[i].z) << 16);		}	}	const float elapsedTime = WallClockTime() - startTime;	const float sampleSec = height * width / elapsedTime;	sprintf(captionBuffer, "Rendering time %.3f sec (pass %d)  Sample/sec  %.1fK/n",		elapsedTime, currentSample, sampleSec / 1000.f);	currentSample++;}

static voidclean(void){	int i, j, k;	Buf b, path;	Vec dir;	binit(&b);	binit(&path);	vinit(&dir);	for(i=0; i<nelem(cleantab); i++) {		if((streq(cleantab[i], "cmd/prof")) && !isdir(cleantab[i]))			continue;		bpathf(&path, "%s/src/%s", goroot, cleantab[i]);		xreaddir(&dir, bstr(&path));		// Remove generated files.		for(j=0; j<dir.len; j++) {			for(k=0; k<nelem(gentab); k++) {				if(hasprefix(dir.p[j], gentab[k].nameprefix))					xremove(bpathf(&b, "%s/%s", bstr(&path), dir.p[j]));			}		}		// Remove generated binary named for directory.		if(hasprefix(cleantab[i], "cmd/"))			xremove(bpathf(&b, "%s/%s", bstr(&path), cleantab[i]+4));	}	// remove src/pkg/runtime/z* unconditionally	vreset(&dir);	bpathf(&path, "%s/src/pkg/runtime", goroot);	xreaddir(&dir, bstr(&path));	for(j=0; j<dir.len; j++) {		if(hasprefix(dir.p[j], "z"))			xremove(bpathf(&b, "%s/%s", bstr(&path), dir.p[j]));	}	if(rebuildall) {		// Remove object tree.		xremoveall(bpathf(&b, "%s/pkg/obj/%s_%s", goroot, gohostos, gohostarch));		// Remove installed packages and tools.		xremoveall(bpathf(&b, "%s/pkg/%s_%s", goroot, gohostos, gohostarch));		xremoveall(bpathf(&b, "%s/pkg/%s_%s", goroot, goos, goarch));		xremoveall(tooldir);		// Remove cached version info.		xremove(bpathf(&b, "%s/VERSION.cache", goroot));	}	bfree(&b);	bfree(&path);	vfree(&dir);}

double vecvecadd(size_t N, size_t iterations = 1){        double* a = new double[N];    double* b = new double[N];    double* c = new double[N];        vinit(N, a);    vinit(N, b);        std::vector<double> times;    for(size_t i = 0; i < iterations; ++i){                auto start = std::chrono::steady_clock::now();                for(size_t i = 0; i < N; ++i){            c[i] = a[i] + b[i];        }        auto end = std::chrono::steady_clock::now();                auto diff = end - start;        times.push_back(std::chrono::duration<double, std::milli> (diff).count()); //save time in ms for each iteration    }        delete [] a;    delete [] b;    delete [] c;        double tmin = *(std::min_element(times.begin(), times.end()));    double tavg = average_time(times);    /*     // check to see if nothing happened during rum to invalidate the times     if(tmin*(1.0 + deviation*0.01) < tavg){     std::cerr << "uBLAS kernel 'vecvecadd': Time deviation too large!!!" << std::endl;     }     */    return tavg;    }

static voidclean(void){	int i, j, k;	Buf b, path;	Vec dir;	binit(&b);	binit(&path);	vinit(&dir);	for(i=0; i<nelem(cleantab); i++) {		bpathf(&path, "%s/src/%s", goroot, cleantab[i]);		xreaddir(&dir, bstr(&path));		// Remove generated files.		for(j=0; j<dir.len; j++) {			for(k=0; k<nelem(gentab); k++) {				if(hasprefix(dir.p[j], gentab[k].nameprefix))					xremove(bpathf(&b, "%s/%s", bstr(&path), dir.p[j]));			}		}		// Remove generated binary named for directory.		if(hasprefix(cleantab[i], "cmd/"))			xremove(bpathf(&b, "%s/%s", bstr(&path), cleantab[i]+4));	}	// remove src/runtime/zaexperiment.h and 	// except leave zgoos and zgoarch, now maintained with go generate.	bpathf(&path, "%s/src/runtime", goroot);	for(j=0; j<nelem(runtimegen); j++)		xremove(bpathf(&b, "%s/%s", bstr(&path), runtimegen[j]));	if(rebuildall) {		// Remove object tree.		xremoveall(bpathf(&b, "%s/pkg/obj/%s_%s", goroot, gohostos, gohostarch));		// Remove installed packages and tools.		xremoveall(bpathf(&b, "%s/pkg/%s_%s", goroot, gohostos, gohostarch));		xremoveall(bpathf(&b, "%s/pkg/%s_%s", goroot, goos, goarch));		xremoveall(tooldir);		// Remove cached version info.		xremove(bpathf(&b, "%s/VERSION.cache", goroot));	}	bfree(&b);	bfree(&path);	vfree(&dir);}

/* init1(): * This is the first level of initialization (aside from the most fundamental * stuff that must be done in reset.s) that is done after the system resets. */voidinit1(void){    initCPUio();        /* Configure all chip-selects, parallel IO                         * direction registers, etc...  This may have                         * been done already in reset.s                         */    vinit();            /* Initialize the CPU's vector table. */    InitRemoteIO();     /* Initialize all application-settable IO functions */    if(ConsoleBaudRate == 0) {        ConsoleBaudRate = DEFAULT_BAUD_RATE;    }    devInit(ConsoleBaudRate);}