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);
}
