void ClockTest::testClock()
{
Clock t1;
Thread::sleep(200);
Clock t2;
Clock t3 = t2;
assert (t1 != t2);
assert (!(t1 == t2));
assert (t2 > t1);
assert (t2 >= t1);
assert (!(t1 > t2));
assert (!(t1 >= t2));
assert (t2 == t3);
assert (!(t2 != t3));
assert (t2 >= t3);
assert (t2 <= t3);
Clock::ClockDiff d = (t2 - t1);
assert (d >= 180000 && d <= 300000);
Clock::ClockDiff acc = Clock::accuracy();
assert (acc > 0 && acc < Clock::resolution());
std::cout << "Clock accuracy: " << acc << std::endl;
t1.swap(t2);
assert (t1 > t2);
t2.swap(t1);
Clock now;
Thread::sleep(201);
assert (now.elapsed() >= 200000);
assert (now.isElapsed(200000));
assert (!now.isElapsed(2000000));
}
Notification* TimedNotificationQueue::waitDequeueNotification(long milliseconds)
{
while (milliseconds >= 0)
{
_mutex.lock();
NfQueue::iterator it = _nfQueue.begin();
if (it != _nfQueue.end())
{
_mutex.unlock();
Clock now;
Clock::ClockDiff sleep = it->first - now;
if (sleep <= 0)
{
return dequeueOne(it).duplicate();
}
else if (sleep <= 1000*Clock::ClockDiff(milliseconds))
{
if (!wait(sleep))
{
return dequeueOne(it).duplicate();
}
else
{
milliseconds -= static_cast<long>((now.elapsed() + 999)/1000);
continue;
}
}
}
else
{
_mutex.unlock();
}
if (milliseconds > 0)
{
Clock now;
_nfAvailable.tryWait(milliseconds);
milliseconds -= static_cast<long>((now.elapsed() + 999)/1000);
}
else return 0;
}
return 0;
}
bool TimedNotificationQueue::wait(Clock::ClockDiff interval)
{
const Clock::ClockDiff MAX_SLEEP = 8*60*60*Clock::ClockDiff(1000000); // sleep at most 8 hours at a time
while (interval > 0)
{
Clock now;
Clock::ClockDiff sleep = interval <= MAX_SLEEP ? interval : MAX_SLEEP;
if (_nfAvailable.tryWait(static_cast<long>((sleep + 999)/1000)))
return true;
interval -= now.elapsed();
}
return false;
}
int main() {
unsigned N = 512;
Matrix A(N, N, 1);
Matrix B(N, N, 2);
Matrix C(N, N, 5.76);
double alpha = 3.14;
Clock c;
c.start();
Matrix D = A*B + alpha*B + alpha*A + C;
double time = c.elapsed();
std::cout << "D(0,0) = " << D(0,0)
<< " computed in " << time << " secs"<< std::endl;
}
void LightRunning::setMode(WheelEnum::RATE mode)
{
init();
std::pair<int, int> green_blue = getYellowGreen(mode);
const int green = green_blue.first;
const int blue = green_blue.second;
assert(green + blue <= 24);
srand(ck.elapsed() *100.f);
for(int g = green; g>0; --g)
{
_lights->push_random(WheelEnum::Yellow, WheelEnum::Red);
}
for(int b = blue; b>0; --b)
{
_lights->push_random(WheelEnum::Green, WheelEnum::Red);
}
_running = true;
}
inline double FpsCounter::elapsed()
{
return (rolex_.isRunning()) ? rolex_.elapsed() : elapsed_;
}
int main() {
srand(time(NULL));
system("clear");
unsigned int numeroElementos;
do {
cout << "Introduce el número de elementos del vector: ";
cin >> numeroElementos;
} while (not numeroElementos);
/** PARAMETROS PARA LAS MEDICIONES **/
Quicksort qs;
QuicksortInsercion qsI;
QuicksortMediana qsM;
unsigned int elementosInsercion = 0;
do {
cout << endl << "Introduzca el limite inferior para ordenar el vector segun el metodo de Insercion: ";
cin >> elementosInsercion;
} while (0 >= elementosInsercion);
qsI.setElementosInsercion(elementosInsercion);
unsigned int elementosMediana = 0;
do {
cout << "Introduzca el limite para usar la mediana en el quicksort: ";
cin >> elementosMediana;
} while (0 >= elementosMediana);
qsM.setElementosMediana(elementosMediana);
cout << endl;
/**********************************************/
/** MEDICIONES **/
Clock clock;
Medicion quicksort, quicksortInsercion, quicksortMediana;
vector<int> vector, aux, auxII, auxIII;
rellenarVector(vector, numeroElementos);
aux = vector;
cout << endl << endl << "Número de elementos: " << numeroElementos << endl;
/*** QUICKSORT ***/
clock.start();
qs.quickSort(aux, 0, aux.size()-1);
clock.stop();
assert(estaOrdenado(aux));
quicksort.appendTime(clock.elapsed());
quicksort.appendX(numeroElementos);
cout << endl << " tiempo Quicksort : " << clock.elapsed() << endl;
cout << endl;
/*** QUICKSORT - INSERCION ***/
for (unsigned int j = elementosInsercion; j < elementosInsercion*10; j+= elementosInsercion) {
auxII = vector;
assert(auxII == vector);
qsI.setElementosInsercion(j);
clock.start();
qsI.quickSort(auxII, 0, auxII.size()-1);
clock.stop();
assert(estaOrdenado(auxII));
quicksortInsercion.appendTime(clock.elapsed());
quicksortInsercion.appendX(j);
cout << " tiempo Quicksort-Insercion (x=" << j << "): " << clock.elapsed() << endl;
}
cout << endl;
/*** QUICKSORT - MEDIANA ***/
for (unsigned int j = elementosMediana; j < elementosMediana*10; j+=elementosMediana) {
auxIII = vector;
assert(auxIII == vector);
qsM.setElementosMediana(j);
clock.start();
qsM.quickSort(auxIII, 0, auxIII.size()-1);
clock.stop();
assert(estaOrdenado(auxIII));
quicksortMediana.appendTime(clock.elapsed());
quicksortMediana.appendX(j);
cout << " tiempo Quicksort-Mediana (x=" << j << "): " << clock.elapsed() << endl;
}
//COMPROBAR QUE TODOS LOS VECTORES TIENEN LOS MISMOS ELEMENTOS EN EL MISMO ORDEN
for (unsigned int i = 0; i < aux.size(); i++) {
assert(aux[i] == auxII[i]);
assert(auxII[i] == auxIII[i]);
}
vector.clear();
aux.clear();
auxII.clear();
auxIII.clear();
guardarDatos(
numeroElementos,
//Como solo se usa una vez el Quicksort normal se coge el valor que tarda en ordenar
quicksort.getTiempos()[0],
quicksortInsercion.getTiempos(),
quicksortInsercion.getNumElementos(),
quicksortMediana.getTiempos(),
quicksortMediana.getNumElementos()
);
return 0;
}
//The protocol/transport stack test driver
//
// Reads two command line arguments
// Arg1 chooses the transport, memory or file (m|f)
// Arg2 chooses the protocol, binary/compact/json (b|c|j)
// example:
// proto_write_times f j
// to run the test with a file transport and JSON protocol
int main(int argc, char *argv[]) {
if (argc != 3) {
std::cout << "usage: " << argv[0]
<< " (m[emory]|f[file]) (b[inary]|c[ompact]|j[son])"
<< std::endl;
return -1;
}
//Set the Transport
boost::shared_ptr<TTransport> trans;
if (argv[1][0] == 'm' || argv[1][0] == 'M') {
const int mem_size = 1024*1024*64;
trans.reset(new TMemoryBuffer(mem_size));
std::cout << "Writing memory, buffer size: " << mem_size
<< std::endl;
}
else if (argv[1][0] == 'f' || argv[1][0] == 'F') {
const std::string path_name("/tmp/thrift_data");
trans.reset(new TSimpleFileTransport(path_name, false, true));
std::cout << "Writing to: " << path_name << std::endl;
}
else {
std::cout << "usage: " << argv[0]
<< " (m[emory]|f[file]) (b[inary]|c[ompact]|j[son])"
<< std::endl;
return -1;
}
//Set the Protocol
std::unique_ptr<TProtocol> proto;
if (argv[2][0] == 'b' || argv[2][0] == 'B')
proto.reset(new TBinaryProtocol(trans));
else if (argv[2][0] == 'c' || argv[2][0] == 'C')
proto.reset(new TCompactProtocol(trans));
else if (argv[2][0] == 'j' || argv[2][0] == 'J')
proto.reset(new TJSONProtocol(trans));
else {
std::cout << "usage: " << argv[0] <<
" (m[emory]|f[file]) (b[inary]|c[ompact]|j[son])"
<< std::endl;
return -1;
}
//Report clock information
Clock<std::chrono::steady_clock> clock;
std::cout << "Clock precision in seconds: " << clock.precision()
<< " (steady: " << clock.isSteady() << ")" << std::endl;
//Init the object (different values can have an affect on
//JSON ad Compact protocol performance !)
Trade trade;
trade.symbol[0] = 'F'; trade.symbol[1] = '\0';
trade.price = 13.10;
trade.size = 2500;
//Serialize the object and write to the transport 1mm times
auto start = clock.now();
int i = 0;
for (int loop_count = 0; loop_count < 1000000; ++loop_count) {
i += proto->writeStructBegin("Trade");
i += proto->writeFieldBegin("symbol",
::apache::thrift::protocol::T_STRING,
1);
i += proto->writeString(std::string(trade.symbol));
i += proto->writeFieldEnd();
i += proto->writeFieldBegin("price",
::apache::thrift::protocol::T_DOUBLE,
2);
i += proto->writeDouble(trade.price);
i += proto->writeFieldEnd();
i += proto->writeFieldBegin("size",
::apache::thrift::protocol::T_I32, 3);
i += proto->writeI32(trade.size);
i += proto->writeFieldEnd();
i += proto->writeFieldStop();
i += proto->writeStructEnd();
}
//Report the results
std::cout << "elapsed: " << clock.elapsed(start, clock.now())
<< std::endl;
std::cout << "Wrote " << i << " bytes" << std::endl;
}
int main(){
moneda c1;
//int euros;
//int centimos;
//int dinero;
char opcion;
bool vflag;
int columnas;
string nombreFichero = "monedas.txt";
string nombreFicheroTiempos = "tiempos.txt";
vector<int> solucion;
vector<double> tiempoVoraz;
double tiempoVorazTotal=0;
vector<double> tiempoDinamico;
double tiempoDinamicoTotal=0;
vector<int> muestras;
Clock reloj;
int repeticiones;
srand(time(NULL));
int incremento;
int numMuestra=0;
//Rellenamos el vector de monedas
c1.leerFichero(nombreFichero);
cout << "Introduce el numero de repeticiones para la media: ";
cin >> repeticiones;
cout << "Introduce el incremento: ";
cin >> incremento;
cout << "¿Desea mostrar los tiempos de cada iteracion por pantalla? (S/n): ";
cin >> opcion;
if(opcion=='S'){
vflag=true;
}else{
vflag=false;
}
/*
cout << "Introduce el numero de euros: ";
cin >> euros;
euros = euros*100;
cout << "Introduce el numero de centimos: ";
cin >> centimos;
dinero = euros+centimos;
*/
//Hacemos la matriz
int ** solucionDin;
//Hacemos el bucle para contar los tiempos y almacenar las muestras
for(int i=50000; i<=100000; i=i+incremento){
for(int j=0; j<repeticiones; j++){
//Reservo memoria
columnas = i+1;
solucionDin = (int**)malloc(c1.getNumeroMonedas()*sizeof(int*));
for(int k=0; k<c1.getNumeroMonedas(); k++){
solucionDin[k] = (int *)malloc(columnas*sizeof(int));
}
//Ya tenemos la matriz reservada
//Hacemos el cambio voraz
reloj.start();
encuentraCambioVoraz(c1.getMonedas(), solucion, i);
reloj.stop();
tiempoVorazTotal = tiempoVorazTotal + reloj.elapsed();
solucion.clear();
//Nos preparamos para la solucion dinamica
c1.ordenaMonedasAsc();
//Hacemos el cambio dinamico
reloj.start();
encuentraCambioDinamico(c1.getMonedas(), columnas, solucionDin);
reloj.stop();
tiempoDinamicoTotal = tiempoDinamicoTotal + reloj.elapsed();
//Y liberamos la memoria de la matriz
for(int k=0; k<c1.getNumeroMonedas(); k++){
free(solucionDin[k]);
}
free(solucionDin);
//Volvemos a ordenar para el metodo voraz
c1.ordenaMonedasDesc();
}
tiempoVoraz.push_back(tiempoVorazTotal/repeticiones);
tiempoDinamico.push_back(tiempoDinamicoTotal/repeticiones);
muestras.push_back(i);
//Lo mostramos por pantalla
if(vflag){
cout << "Muestra: " << i << endl;
cout << "Tiempo voraz: " << tiempoVoraz[numMuestra] << endl;
cout << "Tiempo dinamico: " << tiempoDinamico[numMuestra] << endl;
}
numMuestra++;
}
//Guardamos los tiempos en el fichero
guardaTiempos(muestras, tiempoVoraz, tiempoDinamico, nombreFicheroTiempos);
cout << endl << "Tiempos pasados a fichero" << endl;
/******************************************************************************************************************
Para mostrar la solucion por pantalla del algoritmo dinamico, solucion obtenida por la matriz del numero de monedas
Habria que dar valor a la variable "dinero"
*******************************************************************************************************************/
/*
//Tenemos que ordenar el vector de monedas de manera ascendente para encontrar la solucion dinamica
c1.ordenaMonedasAsc();
c1.muestraMonedas();
columnas = dinero +1;
//Hacemos el cambio dinamico
encuentraCambioDinamico(c1.getMonedas(), columnas, solucionDin);
muestraMatriz(solucionDin,c1.getMonedas(), c1.getNumeroMonedas(), columnas);
solucion.clear();
rellenaSolucionDinamica(solucionDin, c1.getNumeroMonedas(),columnas, c1.getMonedas(), solucion);
//Mostamos la solución tanto si es aproximada como si no lo es
muestraSolucion(c1.getMonedas(), solucion);
*/
}