/**
* @brief Thread function that periodically reads the scaler values
* @param arg ignore. does not take arguments
* @return nothing.
*/
void *thread_measure( void* arg)
{
int i;
while( 1 )
{
// Clear Counters
for( i=0; i<n_vuproms; ++i) {
start_measurement( &(vu[i]) );
}
usleep( sleep_time );
// Save Counters
for( i=0; i<n_vuproms; ++i) {
stop_measurement( &(vu[i]) );
}
// copy values
for( i=0; i<n_vuproms; ++i) {
save_values( &(vu[i]) );
}
if( _iointr )
scanIoRequest( ioinfo );
}
return NULL;
}
uint16_t measure(uint8_t pin) {
start_measurement(pin);
while((toMeasurePins & 1<<pin) != 0) {}
return lastResult;
}
static int create_and_fill_file(const char *path, int number, size_t size,
struct flow *fw)
{
char full_fn[PATH_MAX];
const char *filename;
int fd, fine;
void *buf;
size_t remaining;
uint64_t offset;
ssize_t written;
assert(size > 0);
assert(size % fw->block_size == 0);
/* Create the file. */
full_fn_from_number(full_fn, &filename, path, number);
printf("Creating file %s ... ", filename);
fflush(stdout);
fd = open(full_fn, O_CREAT | O_WRONLY | O_TRUNC, S_IRUSR | S_IWUSR);
if (fd < 0) {
if (errno == ENOSPC) {
printf("No space left.\n");
return 0;
}
err(errno, "Can't create file %s", full_fn);
}
assert(fd >= 0);
/* Obtain the buffer. */
buf = alloca(fw->block_size);
assert(buf);
/* Write content. */
fine = 1;
offset = (uint64_t)number * GIGABYTES;
remaining = size;
start_measurement(fw);
while (remaining > 0) {
offset = fill_buffer(buf, fw->block_size, offset);
written = write(fd, buf, fw->block_size);
if (written < 0) {
if (errno == ENOSPC) {
fine = 0;
break;
} else
err(errno, "Write to file %s failed", full_fn);
}
assert(written == fw->block_size);
remaining -= written;
measure(fd, fw);
}
assert(!fine || remaining == 0);
end_measurement(fd, fw);
close(fd);
printf("OK!\n");
return fine;
}
int main() {
int i = read_int();
start_measurement();
int res = fib(i);
end_measurement();
print_int(res);
return 0;
}
void update() {
lastResult = ADC;
measuredPin = ADMUX & 0b11111;
toMeasurePins &= ~(1<< measuredPin);
status = ADC_IDLE;
if(toMeasurePins != 0) {
start_measurement(selectNexPin());
}
}
void request_frequency_measurement()
{
uint8_t sreg = SREG;
cli();
if( SBIT( TIMSK0, TOIE0 ) ) // The overflow interrupt enable bit is only set while measuring
{
measurement_requested = 1; // Start measurement once no matter how many requestes are made.
SREG = sreg;
}
else // If no measurement is going on, we can start one directly
{
SREG = sreg;
start_measurement();
}
}
static void measure(int fd, struct flow *fw)
{
long delay;
fw->written_blocks++;
fw->total_written += fw->block_size;
if (fw->written_blocks < fw->blocks_per_delay)
return;
assert(!fdatasync(fd));
assert(!gettimeofday(&fw->t2, NULL));
/* Help the kernel to help us. */
assert(!posix_fadvise(fd, 0, 0, POSIX_FADV_DONTNEED));
delay = delay_ms(&fw->t1, &fw->t2);
switch (fw->state) {
case FW_INC:
if (delay > fw->delay_ms) {
move_to_search(fw,
fw->blocks_per_delay - fw->step / 2,
fw->blocks_per_delay);
} else if (delay < fw->delay_ms) {
inc_step(fw);
} else
move_to_steady(fw);
break;
case FW_DEC:
if (delay > fw->delay_ms) {
dec_step(fw);
} else if (delay < fw->delay_ms) {
move_to_search(fw, fw->blocks_per_delay,
fw->blocks_per_delay + fw->step / 2);
} else
move_to_steady(fw);
break;
case FW_SEARCH:
if (fw->bpd2 - fw->bpd1 <= 3) {
move_to_steady(fw);
break;
}
if (delay > fw->delay_ms) {
fw->bpd2 = fw->blocks_per_delay;
fw->blocks_per_delay = (fw->bpd1 + fw->bpd2) / 2;
} else if (delay < fw->delay_ms) {
fw->bpd1 = fw->blocks_per_delay;
fw->blocks_per_delay = (fw->bpd1 + fw->bpd2) / 2;
} else
move_to_steady(fw);
break;
case FW_STEADY:
update_mean(fw);
if (delay <= fw->delay_ms) {
move_to_inc(fw);
}
else if (fw->blocks_per_delay > 1) {
move_to_dec(fw);
}
break;
default:
assert(0);
}
if (fw->progress) {
/* Instantaneous speed. */
double inst_speed =
(double)fw->blocks_per_delay * fw->block_size * 1000 /
fw->delay_ms;
const char *unit = adjust_unit(&inst_speed);
double percent;
/* The following shouldn't be necessary, but sometimes
* the initial free space isn't exactly reported
* by the kernel; this issue has been seen on Macs.
*/
if (fw->total_size < fw->total_written)
fw->total_size = fw->total_written;
percent = (double)fw->total_written * 100 / fw->total_size;
erase(fw->erase);
fw->erase = printf("%.2f%% -- %.2f %s/s",
percent, inst_speed, unit);
assert(fw->erase > 0);
if (fw->measurements > 0)
fw->erase += pr_time(
(fw->total_size - fw->total_written) /
get_avg_speed(fw));
fflush(stdout);
}
start_measurement(fw);
}
uint16_t measure(uint8_t pin) {
start_measurement(pin);
while(measuredPin != pin) {}
return lastResult;
}
void main() {
start_measurement();
int res = fib(15);
end_measurement();
print_int(res);
}
