Example #1
0
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));
}
Example #2
0
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;
}
Example #3
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;
}
Example #4
0
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;
}
Example #5
0
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_;
}
Example #7
0
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;
}
Example #9
0
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);

*/

}