main(void) { long int i; rseed(clock()); for(i=0;i<100000;i++) printf("%g %g\n",unirnd(),normrnd()); }
// rshapes draws shapes with random colors, strokes, and sizes. void rshapes(int width, int height, int n) { int i, j, np = 10; VGfloat sx, sy, cx, cy, px, py, ex, ey, pox, poy; VGfloat polyx[np], polyy[np]; rseed(); Start(width, height); for (i = 0; i < n; i++) { Fill(randcolor(), randcolor(), randcolor(), drand48()); Ellipse(randf(width), randf(height), randf(200), randf(100)); Circle(randf(width), randf(height), randf(100)); Rect(randf(width), randf(height), randf(200), randf(100)); Arc(randf(width), randf(height), randf(200), randf(200), randf(360), randf(360)); sx = randf(width); sy = randf(height); Stroke(randcolor(), randcolor(), randcolor(), 1); StrokeWidth(randf(5)); Line(sx, sy, sx + randf(200), sy + randf(100)); StrokeWidth(0); sx = randf(width); sy = randf(height); ex = sx + randf(200); ey = sy; cx = sx + ((ex - sx) / 2.0); cy = sy + randf(100); Qbezier(sx, sy, cx, cy, ex, ey); sx = randf(width); sy = randf(height); ex = sx + randf(200); ey = sy; cx = sx + ((ex - sx) / 2.0); cy = sy + randf(100); px = cx; py = sy - randf(100); Cbezier(sx, sy, cx, cy, px, py, ex, ey); pox = randf(width); poy = randf(height); for (j = 0; j < np; j++) { polyx[j] = pox + randf(200); polyy[j] = poy + randf(100); } Polygon(polyx, polyy, np); pox = randf(width); poy = randf(height); for (j = 0; j < np; j++) { polyx[j] = pox + randf(200); polyy[j] = poy + randf(100); } Polyline(polyx, polyy, np); } Fill(128, 0, 0, 1); Text(20, 20, "OpenVG on the Raspberry Pi", 32); End(); }
unsigned int Randomize() //We're in 32 bit so int means long. { /* This uses the time to install a random seed */ /* Return the seed in case you want it for a regression test.*/ time_t timeslot; //2017 wants special type time(×lot); /* unix time function is seconds since 1970*/ rseed( (unsigned long)timeslot ); return (unsigned int)timeslot; }
unsigned int Randomize() { /* This uses the time to install a random seed */ /* Return the seed in case you want it for a regression test.*/ long timeslot; unsigned int seed; //We're in 16 bit, so int means short. time(×lot); /* unix time function is seconds since 1970*/ seed = (unsigned int) (timeslot & 0x0000FFFFL); rseed( seed ); return seed; }
static libgomp_lithe_context_t *__ctx_alloc(size_t stacksize) { libgomp_lithe_context_t *ctx = wfl_remove(&context_zombie_list); if (!ctx) { int offset = ROUNDUP(sizeof(libgomp_lithe_context_t), ARCH_CL_SIZE); offset += rand_r(&rseed(0)) % max_vcores() * ARCH_CL_SIZE; stacksize = ROUNDUP(stacksize + offset, PGSIZE); void *stackbot = mmap( 0, stacksize, PROT_READ|PROT_WRITE|PROT_EXEC, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0 ); if (stackbot == MAP_FAILED) abort(); ctx = stackbot + stacksize - offset; ctx->context.stack_offset = offset; ctx->context.context.stack.bottom = stackbot; ctx->context.context.stack.size = stacksize - offset; } return ctx; }
// sunearth shows the relative sizes of the sun and the earth void sunearth(int w, int h) { VGfloat sun, earth, x, y; int i; rseed(); Start(w, h); Background(0, 0, 0); Fill(255, 255, 255, 1); for (i = 0; i < w / 4; i++) { x = randf(w); y = randf(h); Circle(x, y, 2); } earth = (VGfloat) w *0.010; sun = earth * 109; Fill(0, 0, 255, 1); Circle(w / 3, h - (h / 10), earth); Fill(255, 255, 224, 1); Circle(w, 0, sun); End(); }
int main(int, char**) { std::random_device rseed; std::mt19937 rng(rseed()); std::vector<int> v(100);//reserve 100 elems for(int i = 0; i < 100; ++i) v[i] = i;//add values for(auto& elem : v) std::cout << elem << " ";//print values std::cout << "\n"; std::shuffle(std::begin(v), std::end(v), rng); for(auto& elem : v) std::cout << elem << " ";//print values std::cout << "\n"; std::sort(std::begin(v), std::end(v)); for(auto& elem : v) std::cout << elem << " ";//print values std::cout << "\n"; std::cout << std::endl; }
void SorterVector(){ std::vector<int> Vector; int i = 0; //srand(time(NULL)); std::random_device rseed; std::mt19937 rgen(rseed()); // mersenne_twister std::uniform_int_distribution<int>dist(0,100); //std::mt19937 mt(1729); //std::uniform_int_distribution<int> dist(0,99); while(i < 10){ Vector.push_back(dist(rgen)); i++; } std::cout<< "The random numbers are: " << std::endl; std::copy(Vector.begin(), Vector.end(), std::ostream_iterator<int>(std::cout, "\n")); std::sort(Vector.begin(), Vector.end()); std:: cout << "Vector sorted is: " <<std::endl; std::copy(Vector.begin(), Vector.end(), std::ostream_iterator<int>(std::cout, "\n")); std::cout << "The maximum value is " << *std::max_element(Vector.begin(),Vector.end()) << std::endl; std::cout << "The minimum value is " << *std::min_element(Vector.begin(),Vector.end()) << std::endl; return; }
std::pair<int, int> simulacion(int bloques, int bloque_size, int vias, int accesos, int pagina_size) { int paginas_disco, paginas_mem, fallos_pagina, fallos_cache, bits_offset, div_virt, div_fisica; std::cout << "Numero de bloques: " << bloques << std::endl; std::cout << "Tamano de bloque: " << bloque_size << std::endl; std::cout << "Numero de vias: " << vias << std::endl; std::cout << "Numero de accesos: " << accesos << std::endl; std::cout << "Tamanio de pagina: " << pagina_size << std::endl; std::cout << "Inicializando..."; std::random_device rseed; // Para numeros aleatorios std::mt19937 rgen(rseed()); // mersenne_twister std::uniform_int_distribution<int> idist(0, DIR_VIRUTALES - 1); // [0,4095] std::uniform_int_distribution<int> odist(0, 1); // [0,1] std::uniform_int_distribution<int> ddist(0, 255); // [0,255] std::uniform_int_distribution<int> nueva_dist(256, 511); // [0,255] /* ins_virtuales[*][x], x: 0 - direccion, 1 - lectura/escritura, 2 - dato */ std::vector<std::vector<int> > ins_virtuales (accesos, std::vector<int> (3,0)); std::vector<int> memoria (POS_MEMORIA); std::vector<int> disco (POS_DISCO); t_tabla tabla; /* Creamos la cache */ Cache mem_cache (vias, bloques, bloque_size); /* Inicializacion */ paginas_disco = POS_DISCO / pagina_size; paginas_mem = POS_MEMORIA / pagina_size; std::uniform_int_distribution<int> mdist(0, paginas_mem-1); // [0,paginas_memoria] fallos_pagina = 0; fallos_cache = 0; bits_offset = bits_para(pagina_size); div_virt = potencia(bits_offset);// para posterior division div_fisica = potencia(bits_para(bloque_size));// para posterior division std::cout << " Inicializacion terminada!" << std::endl; std::cout << "Paginas Memoria: " << paginas_mem << std::endl; std::cout << "Paginas Disco: " << paginas_disco << std::endl; std::cout << "Generando instrucciones..." << std::endl; /* Generar instrucciones virtuales */ for (int i = 0; i < accesos; ++i) { ins_virtuales[i][0] = idist(rgen); ins_virtuales[i][1] = odist(rgen); ins_virtuales[i][2] = nueva_dist(rgen); } std::cout << " Terminado!" << std::endl; std::cout << "Generando tabla de traduccion..." << std::endl; /* Generamos la tabla de traduccion */ int contador; for (contador = 0; contador < accesos; ++contador) { int tmp = ins_virtuales[contador][0]/div_virt; if(tabla.size() > paginas_mem) break; if(tabla.count(tmp) == 0) { tabla[tmp].push_back(odist(rgen)); /* 1 - memoria principal */ tabla[tmp].push_back(0); /* 1 - dato en disco mem llena */ tabla[tmp].push_back(contador); /* dir fisica */ } } for (; contador < accesos; ++contador) { int tmp = ins_virtuales[contador][0]/div_virt; if(tabla.size() >= (paginas_mem + paginas_disco)) break; if(tabla.count(tmp) == 0) { tabla[tmp].push_back(0); /* 1 - memoria principal */ tabla[tmp].push_back(1); /* 1 - dato en disco mem llena */ tabla[tmp].push_back(contador); /* dir disco */ } } std::cout << " Terminado!" << std::endl; std::cout << " Tamaño tabla: " << tabla.size() << std::endl; /* leemos la memoria y el disco */ std::ifstream inputmem; std::ifstream inputdisc; std::string outmem; std::string outdisc; int valor_io; int contador_io = 0; std::cout << "Leyendo memoria..." << std::endl; inputmem.open("memoria.txt", std::ifstream::in); while(inputmem >> valor_io) { memoria[contador_io] = valor_io; contador_io++; } inputmem.close(); std::cout << " Terminado!" << std::endl; if (contador_io == 0) { std::cout << "Memoria vacia, abortando!" << std::endl; return std::make_pair(0,0); } std::cout << "Leyendo disco..." << std::endl; inputdisc.open("disco.txt", std::ifstream::in); contador_io = 0; while(inputdisc >> valor_io) { disco[contador_io] = valor_io; contador_io++; } inputdisc.close(); std::cout << " Terminado!" << std::endl; if (contador_io == 0) { std::cout << "Disco vacio, abortando!" << std::endl; return std::make_pair(0,0); } std::cout << "Procesando instrucciones..." << std::endl; /* Iteramos en cada instruccion */ int dir_fisica, tmp, tmp2; std::vector<int> movimiento (bloque_size,0); std::vector<int> respuesta_cache; for (int i = 0; i < accesos; ++i) { /* Traducimos direccion virtual a fisica */ dir_fisica = ins_virtuales[i][0]/div_virt; /* No esta en memoria principal? */ if(tabla[dir_fisica][0] == 0) { //std::cout << "Fallo Pagina!" << std::endl; tabla[dir_fisica][0] = 1; fallos_pagina++; // nuevo fallo de pagina tmp2 = tabla[dir_fisica][2]; // direccion disco /* no esta asigana? */ if(tabla[dir_fisica][1] == 1) { tabla[dir_fisica][1] = 0; tmp = mdist(rgen); // nueva asignacion. tabla[dir_fisica][2] = tmp; /* Movemos de disco a memoria */ } else tmp = tmp2; // Si esta asignada disco - memoria concuerdan. tmp = tmp * div_virt; tmp2 = tmp2 * div_virt; for(int j = 0; j < pagina_size; ++j) { memoria[tmp + j] = disco[tmp2 + j]; } } /* El dato ya esta en memoria principal */ /* Extraemos direccion fisica */ dir_fisica = tabla[dir_fisica][2] * div_virt; /* Agregamos el offset */ dir_fisica = dir_fisica + (ins_virtuales[i][0] % div_virt); /* Cargamos los datos que hay en la memoria por si hay un miss en cache */ tmp = dir_fisica - (dir_fisica % div_fisica); // quitamos el offset de un bloque. for (int j = 0; j < bloque_size; ++j) { movimiento[j] = memoria[tmp + j]; } /* Lectura o escritura */ if (ins_virtuales[i][1] == 0) { //std::cout << "Read" << std::endl; respuesta_cache = mem_cache.read_cache(dir_fisica, movimiento); } else { //::cout << "Write" << std::endl; respuesta_cache = mem_cache.write_cache(dir_fisica, movimiento, ins_virtuales[i][2]); } /* Analimamos la respuesta de la cache */ /* no fue un hit? */ if(respuesta_cache[0] != 1) fallos_cache++; /* hay que escribir en memoria, por write-back? */ if (respuesta_cache[1] == 1) { //std::cout << "write-back" << std::endl; tmp = respuesta_cache[2]; // donde, escribir tmp = tmp - (tmp % div_fisica); // quitamos el offset del bloque. for (int j = 0; j < bloque_size; ++j) { memoria[tmp + j] = respuesta_cache[3+j]; } } } std::cout << " Terminado!" << std::endl; std::cout << "Reescribiendo memoria..." << std::endl; /* Excribimos en los archivos */ std::ofstream ofm ("memoria.txt", std::ofstream::out); for (int i = 0; i < POS_MEMORIA; ++i) { ofm << memoria[i] << "\n"; } ofm.close(); std::cout << "Terminado!" << std::endl; std::cout << "Reescribiendo disco..." << std::endl; std::ofstream ofd ("disco.txt", std::ofstream::out); for (int i = 0; i < POS_DISCO; ++i) { ofd << disco[i] << "\n"; } ofd.close(); std::cout << "Terminado!" << std::endl; std::cout << fallos_pagina << " " << fallos_cache << std::endl; return std::make_pair(fallos_pagina, fallos_cache); }