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