int
main(int ac, char **av)
{
long long count = 0;
long long max;
char c;
int j;
printf("timing standard getuid() syscall, single thread\n");
printf("if using powerd, run several times\n");
start_timing();
while (stop_timing(0, NULL) == 0) {
for (j = 0; j < 100; ++j)
getuid();
count += 100;
}
max = count;
start_timing();
for (count = 0; count < max; count += 100) {
for (j = 0; j < 100; ++j)
getuid();
}
stop_timing(count, "getuid()");
return(0);
}
int
main(int ac, char **av)
{
long long count = 0;
long long max;
struct timespec ts;
int j;
printf("timing standard clock_gettime() syscall\n");
start_timing();
while (stop_timing(0, NULL) == 0) {
for (j = 0; j < 100; ++j)
clock_gettime(CLOCK_REALTIME_FAST, &ts);
count += 100;
}
max = count;
start_timing();
for (count = 0; count < max; count += 100) {
for (j = 0; j < 100; ++j)
clock_gettime(CLOCK_REALTIME_FAST, &ts);
}
stop_timing(count, "getuid()");
return(0);
}
int
main(int ac, char **av)
{
long long count = 0;
long long max;
int j;
struct timeval tv;
printf("timing standard gettimeofday() syscall\n");
start_timing();
while (stop_timing(0, NULL) == 0) {
for (j = 0; j < 100; ++j)
gettimeofday(&tv, NULL);
count += 100;
}
max = count;
start_timing();
for (count = 0; count < max; count += 100) {
for (j = 0; j < 100; ++j)
gettimeofday(&tv, NULL);
}
stop_timing(count, "gettimeofday()");
return(0);
}
/* Determines the overhead of tsc timing. Note the start/stop calls are
* inlined, so we're trying to determine the lowest amount of overhead
* attainable by using the TSC (or whatever timing source).
*
* For more detailed TSC measurements, use test_rdtsc() in k/a/i/rdtsc_test.c */
void train_timing()
{
uint64_t min_overhead = UINT64_MAX;
uint64_t max_overhead = 0;
uint64_t time, diff;
int8_t irq_state = 0;
/* Reset this, in case we run it again. The use of start/stop to determine
* the overhead relies on timing_overhead being 0. */
system_timing.timing_overhead = 0;
/* timing might use cpuid, in which case we warm it up to avoid some extra
* variance */
time = start_timing();
diff = stop_timing(time);
time = start_timing();
diff = stop_timing(time);
time = start_timing();
diff = stop_timing(time);
disable_irqsave(&irq_state);
for (int i = 0; i < 10000; i++) {
time = start_timing();
diff = stop_timing(time);
min_overhead = MIN(min_overhead, diff);
max_overhead = MAX(max_overhead, diff);
}
enable_irqsave(&irq_state);
system_timing.timing_overhead = min_overhead;
printk("TSC overhead (Min: %llu, Max: %llu)\n", min_overhead, max_overhead);
}
void
test_using(const char *ctl, char *buf, int bytes, void (*copyf)(const void *s1, void *d, size_t bytes))
{
int i;
int loops;
long long us;
start_timing();
for (i = 0; (i & 31) || stop_timing(0, NULL) == 0; ++i) {
copyf(buf, buf + bytes, bytes);
}
loops = i * 2;
start_timing();
for (i = loops - 1; i >= 0; --i) {
copyf(buf, buf + bytes, bytes);
}
#if 0
fpcleanup();
#endif
stop_timing(loops, ctl);
us = get_timing();
printf("%s %d %5.2f MBytes/sec\n", ctl, bytes,
(double)loops * (double)bytes / (double)us);
}
int
main(int ac, char **av)
{
long long count = 0;
long long max;
int j;
int *counter;
pid_t pid;
printf("Test simple locked bus cycle mutex latency\n");
printf("auto-forks two processes for the test with shared memory\n");
printf("This test is only useful on a SMP box\n");
start_timing();
mtx = mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_SHARED|MAP_ANON, -1, 0);
counter = mtx + 64;
while (stop_timing(0, NULL) == 0) {
for (j = 0; j < 100; ++j) {
get_mtx(1);
rel_mtx();
}
count += 100;
}
max = count;
*mtx = 0;
start_timing();
for (count = 0; count < max; count += 100) {
for (j = 0; j < 100; ++j) {
get_mtx(1);
rel_mtx(); /* release */
++counter[64];
}
}
stop_timing(count, "complex_mtx(uncontested/1cpu)");
if ((pid = fork()) == 0) {
for (;;) {
for (j = 0; j < 100; ++j) {
get_mtx(2);
rel_mtx(); /* release */
++counter[128];
}
}
} else {
start_timing();
for (count = 0; count < max; count += 100) {
for (j = 0; j < 100; ++j) {
get_mtx(1);
rel_mtx(); /* release */
++counter[64];
}
}
stop_timing(count, "complex_mtx");
printf("proc1=%d proc2=%d\n", counter[64], counter[128]);
kill(pid, 9);
}
return(0);
}
int
main(int ac, char **av)
{
long long count = 0;
long long max;
char c[1];
int j;
int loops;
int fds[2];
printf("tests full duplex pipe 1write,2read,2write,1read loop\n");
if (pipe(fds)) {
perror("pipe");
exit(1);
}
if (fork() == 0) {
/*
* child process
*/
close(fds[0]);
while (read(fds[1], c, sizeof(c)) == sizeof(c)) {
write(fds[1], c, sizeof(c));
}
_exit(0);
} else {
/*
* parent process.
*/
close(fds[1]);
write(fds[0], c, sizeof(c)); /* prime the caches */
read(fds[0], c, sizeof(c));
start_timing();
for (j = 0; ; ++j) {
write(fds[0], c, sizeof(c));
if (read(fds[0], c, sizeof(c)) != sizeof(c)) {
fprintf(stderr, "broken pipe during test\n");
exit(1);
}
if ((j & 31) == 0 && stop_timing(0, NULL))
break;
}
loops = j;
start_timing();
for (j = 0; j < loops; ++j) {
write(fds[0], c, sizeof(c));
if (read(fds[0], c, sizeof(c)) != sizeof(c)) {
fprintf(stderr, "broken pipe during test\n");
exit(1);
}
}
stop_timing(j, "full duplex pipe / 1char:");
close(fds[0]);
while(wait(NULL) >= 0);
}
return(0);
}
int
main(int ac, char **av)
{
long long count = 0;
long long max;
char c;
int n;
int i;
int j;
int fd;
int status;
char *path;
char buf[256];
struct stat st;
printf("timing standard fstat() syscall\n");
fd = open("/tmp/lockmgr3.test", O_RDWR|O_CREAT, 0666);
assert(fd >= 0);
start_timing();
while (stop_timing(0, NULL) == 0) {
fstat(fd, &st);
fstat(fd, &st);
fstat(fd, &st);
fstat(fd, &st);
++count;
}
max = count * 4;
close(fd);
if (ac > 1)
n = strtol(av[1], NULL, 0);
else
n = 1;
start_timing();
for (i = 0; i < n; ++i) {
if (fork() == 0) {
asprintf(&path, "/tmp/lockmgr.test");
fd = open(path, O_RDWR|O_CREAT, 0666);
assert(fd >= 0);
for (count = 0; count < max; ++count) {
fstat(fd, &st);
fstat(fd, &st);
fstat(fd, &st);
fstat(fd, &st);
}
_exit(0);
}
}
while (wait3(&status, 0, NULL) >= 0 || errno == EINTR)
;
stop_timing(max * n * 4, "lockmgr3");
return(0);
}
int main(int argc, char *argv[])
{
struct timespec timing;
int i, round;
void *m[ALLOCS];
/* a random set of allocations we test */
int sizes[16] = { 1, 13, 100, 1000, 16, 10000, 50, 17,
123, 32, 8, 64, 8096, 1024, 123, 9 };
library_init(NULL, "malloc_speed");
atexit(library_deinit);
print_mallinfo();
start_timing(&timing);
for (round = 0; round < ROUNDS; round++)
{
for (i = 0; i < ALLOCS; i++)
{
m[i] = malloc(sizes[(round + i) % countof(sizes)]);
}
for (i = 0; i < ALLOCS; i++)
{
free(m[i]);
}
}
printf("time for %d malloc/frees, repeating %d rounds: %.4fs\n",
ALLOCS, ROUNDS, end_timing(&timing));
print_mallinfo();
return 0;
}
//
// wait_till_completed(interval_ms = 0)
//
// params:
// interval_ms - the polling interval in milliseconds. If zero, 1000 ms is used
//
static VALUE wait_till_completed(int argc, VALUE * argv, VALUE self) {
struct timeval tm;
start_timing(&tm);
if ( rb_iv_get(self, "@done") == Qtrue ) return Qtrue;
VALUE interval_ms;
rb_scan_args(argc, argv, "01", &interval_ms);
if ( NIL_P(interval_ms) ) interval_ms = rb_zero;
as_error err;
aerospike * as = get_client_struct(rb_iv_get(self, "@client"));
as_query * query;
Data_Get_Struct(rb_iv_get(self, "@query"), as_query, query);
uint64_t query_id = NUM2ULONG( rb_iv_get(self, "@query_id") );
if ( aerospike_query_wait(as, &err, NULL, query, query_id, FIX2LONG(interval_ms)) != AEROSPIKE_OK ) {
raise_as_error(err);
}
rb_iv_set(self, "@done", Qtrue);
rb_aero_logger(AS_LOG_LEVEL_DEBUG, &tm, 1, rb_str_new2("[QueryTask][wait_till_completed] success"));
return rb_iv_get(self, "@done");
}
int main(int argc, char** argv) {
double* S = malloc_aligned<double>(LENGTH, 5);
double* X = malloc_aligned<double>(LENGTH, 5);
double* T = malloc_aligned<double>(LENGTH, 5);
double* r = malloc_aligned<double>(LENGTH, 5);
double* v = malloc_aligned<double>(LENGTH, 5);
for(int i = 0; i < LENGTH; i++) {
S[i] = 100;
X[i] = 98;
T[i] = 2;
r[i] = 0.02;
v[i] = 5;
}
start_timing();
double sum = 0;
for(int i = 0; i < ROUNDS; i++) {
sum += run(S, X, T, r, v);
}
printf("%f \t(%f)\n", end_timing(), sum / (LENGTH * ROUNDS));
return 0;
}
void rgb_timing(Test **test, Rgb_Timing *timing)
{
double total_time,avg_time;
int i,j;
unsigned int *rand_uint;
MYDEBUG(D_RGB_TIMING){
printf("# Entering rgb_timing(): ps = %u ts = %u\n",test[0]->psamples,test[0]->tsamples);
}
seed = random_seed();
gsl_rng_set(rng,seed);
rand_uint = (uint *)malloc((size_t)test[0]->tsamples*sizeof(uint));
total_time = 0.0;
for(i=0;i<test[0]->psamples;i++){
start_timing();
for(j=0;j<test[0]->tsamples;j++){
rand_uint[j] = gsl_rng_get(rng);
}
stop_timing();
total_time += delta_timing();
}
avg_time = total_time/(test[0]->psamples*test[0]->tsamples);
timing->avg_time_nsec = avg_time*1.0e+9;
timing->rands_per_sec = 1.0/avg_time;
free(rand_uint);
}
static void remap_data(int index, ft_data *ftd){
msg_tag *mtag;
char *temp;
int i;
double dtime = start_timing();
temp = (char *)malloc(sites_on_node*ftd->size);
if(temp==NULL){
printf("remap_data: No room\n");
terminate(1);
}
mtag = start_gather_field(ftd->data, ftd->size, index, EVENANDODD,
gen_pt[0]);
wait_gather(mtag);
/* First copy gathered data to temporary */
for(i = 0; i < sites_on_node; i++)
memcpy(temp + ftd->size*i, gen_pt[0][i], ftd->size);
cleanup_gather(mtag);
/* Then copy temp back to field */
memcpy((char *)ftd->data, temp, sites_on_node*ftd->size);
free(temp);
print_timing(dtime, "REMAP FFTW remap");
}
ft_data *create_ft_data(complex *src, int size){
char myname[] = "create_ft_data";
ft_data *ftd;
int ncmp;
double dtime = start_timing();
ftd = (ft_data *)malloc(sizeof(ft_data));
if(ftd == NULL){
printf("%s: No room\n", myname);
terminate(1);
}
ncmp = size/sizeof(complex);
ftd->size = ncmp*sizeof(fftw_complex);
ftd->dir = MILC_DIR;
ftd->data
= (fftw_complex*) fftw_malloc(sizeof(fftw_complex)*sites_on_node*ncmp);
ftd->tmp
= (fftw_complex*) fftw_malloc(sizeof(fftw_complex)*sites_on_node*ncmp);
if(ftd->data == NULL || ftd->tmp == NULL){
printf("%s: no room\n",myname);
terminate(1);
}
/* Copy data in */
ft_copy_from_milc(ftd->data, src, size);
print_timing(dtime, "REMAP FFTW copy MILC");
return ftd;
}
static void run_test(diffie_hellman_group_t group, int rounds)
{
diffie_hellman_t *l[rounds], *r;
chunk_t chunk;
struct timespec timing;
int round;
r = lib->crypto->create_dh(lib->crypto, group);
if (!r)
{
printf("skipping %N, not supported\n",
diffie_hellman_group_names, group);
return;
}
printf("%N:\t",
diffie_hellman_group_names, group);
start_timing(&timing);
for (round = 0; round < rounds; round++)
{
l[round] = lib->crypto->create_dh(lib->crypto, group);
}
printf("A = g^a/s: %8.1f", rounds / end_timing(&timing));
for (round = 0; round < rounds; round++)
{
l[round]->get_my_public_value(l[round], &chunk);
r->set_other_public_value(r, chunk);
chunk_free(&chunk);
}
r->get_my_public_value(r, &chunk);
start_timing(&timing);
for (round = 0; round < rounds; round++)
{
l[round]->set_other_public_value(l[round], chunk);
}
printf(" | S = B^a/s: %8.1f\n", rounds / end_timing(&timing));
chunk_free(&chunk);
for (round = 0; round < rounds; round++)
{
l[round]->destroy(l[round]);
}
r->destroy(r);
}
opt_oct_t* opt_oct_assign_linexpr(ap_manager_t* man,
bool destructive, opt_oct_t* o,
ap_dim_t d, ap_linexpr0_t* lexpr,
opt_oct_t* dest)
{
opt_oct_internal_t* pr =
opt_oct_init_from_manager(man,AP_FUNID_ASSIGN_LINEXPR_ARRAY,2*(o->dim+1+5));
opt_uexpr u = opt_oct_uexpr_of_linexpr(pr,pr->tmp,lexpr,o->intdim,o->dim);
opt_oct_mat_t* src;
bool respect_closure;
if(d>=o->dim){
return NULL;
}
if (dest && !dest->closed && !dest->m)
/* definitively empty due to dest*/
return opt_oct_set_mat(pr,o,NULL,NULL,destructive);
if (u.type==OPT_EMPTY)
/* definitively empty due to empty expression */
return opt_oct_set_mat(pr,o,NULL,NULL,destructive);
/* useful to close only for non-invertible assignments */
if ((u.type!=OPT_UNARY || u.i!=d) && pr->funopt->algorithm>=0)
opt_oct_cache_closure(pr,o);
src = o->closed ? o->closed : o->m;
if (!src) return opt_oct_set_mat(pr,o,NULL,NULL,destructive); /* empty */
/* can / should we try to respect the closure */
respect_closure = (src==o->closed) && (pr->funopt->algorithm>=0) && (!dest);
if (!destructive) src = opt_hmat_copy(src,o->dim);
/* go */
#if defined(TIMING)
start_timing();
#endif
opt_hmat_assign(pr,u,src,o->dim,d,&respect_closure);
#if defined(TIMING)
record_timing(assign_linexpr_time);
#endif
/* exact on Q if zeroary or unary, closed arg and no conv error */
if (u.type==OPT_BINARY || u.type==OPT_OTHER) flag_incomplete;
else if (num_incomplete || o->intdim) flag_incomplete;
else if (!o->closed) flag_algo;
else if (pr->conv) flag_conv;
/* intersect with dest */
if (dest) {
opt_oct_mat_t* src2 = dest->closed ? dest->closed : dest->m;
meet_half(src,src,src2,o->dim,true);
}
if (respect_closure) return opt_oct_set_mat(pr,o,NULL,src,destructive);
else return opt_oct_set_mat(pr,o,src,NULL,destructive);
}
void fourier_ftdata( ft_data *ftd, int isign ){
double dtime = start_timing();
if(isign == 1)
fftw_execute(fwd_plan[ftd->dir]);
else
fftw_execute(bck_plan[ftd->dir]);
print_timing(dtime, "FFTW transform");
dtime = start_timing();
/* Copy the result from "tmp" back to "data" */
memcpy((char *)ftd->data, (char *)ftd->tmp, ftd->size*sites_on_node);
print_timing(dtime, "REMAP FFTW copy back");
}
void dijkstra_pq_threaded(CSRGraph *g, int numThreads)
{
int *dist = new int[g->size];
std::mutex *dist_locks = new std::mutex[g->size];
int i;
for(i=0;i<g->size;i++)
{
dist[i] = MAX_INT;
}
int source = 0;
dist[source] = 0;
std::priority_queue<Priority_struct, std::vector<Priority_struct>, Compare_priority> pq;
Priority_struct temp;
temp.node_name=source;
temp.node_weight=0;
pq.push(temp);
printf("Pushed Initial\n");
for(int i=0; i< pq.size();i++){
printf(" %d", pq[i]);
}
printf("\n");
flush_cache();
start_timing();
// make threads
std::vector<std::thread> threads;
for(i = 0; i < numThreads; ++i){
threads.push_back(std::thread(dijkstra_pq_thread, g, dist, std::ref(pq), i, dist_locks));
}
for (auto it = threads.begin(); it != threads.end(); ++it) {
std::thread &t = *it;
t.join();
}
stop_timing();
#ifdef PRINT_DISTANCES
i=0;
while(i < g->size && i < 10)
{
printf("%d ", dist[i]);
i++;
}
printf("\n");
#endif
delete(dist);
delete(dist_locks);
dist = NULL;
}
Time::Time ()
{
if ( !m_Started ) {
m_Started = true;
SetSystemTime (); // Get base time from wall clock
start_timing ( m_CurrTime ); // Start timing from base time
}
m_CurrTime = 0;
}
int
main(int ac, char **av)
{
long long count = 0;
long long max;
char c;
int n;
int i;
int j;
int status;
printf("timing standard getuid() syscall, single thread\n");
printf("if using powerd, run several times\n");
start_timing();
while (stop_timing(0, NULL) == 0) {
for (j = 0; j < 100; ++j)
getuid();
count += 100;
}
max = count;
if (ac > 1)
n = strtol(av[1], NULL, 0);
else
n = 1;
start_timing();
for (i = 0; i < n; ++i) {
if (fork() == 0) {
for (count = 0; count < max; count += 100) {
for (j = 0; j < 100; ++j)
getuid();
}
_exit(0);
}
}
while (wait3(&status, 0, NULL) >= 0 || errno == EINTR)
;
stop_timing(count * n, "getuid()");
return(0);
}
void dijkstra_LIFO_threaded(CSRGraph *g, int numThreads)
{
int *dist = new int[g->size];
std::mutex *dist_locks = new std::mutex[g->size];
int *onstack = new int[g->size];
int i;
for(i=0;i<g->size;i++)
{
dist[i] = MAX_INT;
onstack[i]=0;
}
int source = 0;
dist[source] = 0;
std::deque<int> deq;
deq.push_back(source);
onstack[source]=1;
printf("Pushed initial\n");
for(int i=0; i< deq.size();i++){
printf(" %d", deq[i]);
}
printf("\n");
flush_cache();
start_timing();
// make threads
std::vector<std::thread> threads;
for(i = 0; i < numThreads; ++i){
threads.push_back(std::thread(dijkstra_LIFO_thread, g, dist, std::ref(deq), i, onstack, dist_locks));
}
for (auto it = threads.begin(); it != threads.end(); ++it) {
std::thread &t = *it;
t.join();
}
stop_timing();
#ifdef PRINT_DISTANCES
i=0;
while(i < g->size && i < 10)
{
printf("%d ", dist[i]);
i++;
}
printf("\n");
#endif
delete(onstack);
delete(dist);
delete(dist_locks);
}
static void do_send_fragment(struct ipw_hardware *hw, unsigned char *data,
unsigned length)
{
unsigned i;
unsigned long flags;
start_timing();
BUG_ON(length > hw->ll_mtu);
if (ipwireless_debug)
dump_data_bytes("send", data, length);
spin_lock_irqsave(&hw->lock, flags);
hw->tx_ready = 0;
swap_packet_bitfield_to_le(data);
if (hw->hw_version == HW_VERSION_1) {
outw((unsigned short) length, hw->base_port + IODWR);
for (i = 0; i < length; i += 2) {
unsigned short d = data[i];
__le16 raw_data;
if (i + 1 < length)
d |= data[i + 1] << 8;
raw_data = cpu_to_le16(d);
outw(raw_data, hw->base_port + IODWR);
}
outw(DCR_TXDONE, hw->base_port + IODCR);
} else if (hw->hw_version == HW_VERSION_2) {
outw((unsigned short) length, hw->base_port);
for (i = 0; i < length; i += 2) {
unsigned short d = data[i];
__le16 raw_data;
if (i + 1 < length)
d |= data[i + 1] << 8;
raw_data = cpu_to_le16(d);
outw(raw_data, hw->base_port);
}
while ((i & 3) != 2) {
outw((unsigned short) 0xDEAD, hw->base_port);
i += 2;
}
writew(MEMRX_RX, &hw->memory_info_regs->memreg_rx);
}
spin_unlock_irqrestore(&hw->lock, flags);
end_write_timing(length);
}
void external_dataset_sort(external_dataset_t* data)
{
struct runtime rt;
void* results = NULL;
size_t i;
stream_t* tmp;
stream_t* stream = data->stream;
stream_seek(stream, 0);
tmp = stream_create(stream->config, "tmp.stream");
stream_open(tmp, O_CREAT | O_TRUNC | O_RDWR | O_SYNC);
/* sort each individual chunk of memory size */
for(i = 0; i < data->n_records / MEMORY_RECORDS(stream); i++)
{
memory_read(stream, RECORDS(data->mem), MEMORY_RECORDS(stream));
N_RECORDS(data->mem) = MEMORY_RECORDS(stream);
results = NULL;
start_timing(&rt);
fp_im_sort(data->context, RECORDS(data->mem), N_RECORDS(data->mem), &results);
stop_timing(&rt);
printf("Sort time: %f\n", get_runtime(rt));
memory_write(tmp, RECORDS(data->mem), N_RECORDS(data->mem));
dataset_print(data->mem, TRUE);
}
if(data->n_records % MEMORY_RECORDS(stream))
{
memory_read(stream, RECORDS(data->mem), data->n_records % MEMORY_RECORDS(stream));
N_RECORDS(data->mem) = data->n_records % MEMORY_RECORDS(stream);
start_timing(&rt);
results = NULL;
fp_im_sort(data->context, RECORDS(data->mem), N_RECORDS(data->mem), &results);
stop_timing(&rt);
memory_write(tmp, RECORDS(data->mem), N_RECORDS(data->mem));
dataset_print(data->mem, TRUE);
}
/* merge memory chunks block by block */
}
static void* check_updates_worker(void* arg){
timing_info timing;
reset_timing(&timing);
while(!stop){
start_timing(&timing);
if(!updated && push_commit){
if(push_commit){
pthread_mutex_lock(&commit_mutex);
if(push_result_shell(push_commit, NULL)){
puts("Failed to push coin, reseting.");
pthread_mutex_lock(&update_mutex);
fetch_updates();
updated = 1;
pthread_mutex_unlock(&update_mutex);
} else {
puts("Earned it!");
}
push_commit = NULL;
pthread_mutex_unlock(&commit_mutex);
} else {
if(check_updates()){
pthread_mutex_lock(&update_mutex);
updated = 1;
pthread_mutex_unlock(&update_mutex);
}
}
time_point(&timing);
print_timing(&timing);
} else {
skip_point(&timing);
usleep(10);
}
}
puts("Update thread ending");
pthread_exit(NULL);
}
static void ft_make_maps(ft_layout *ftl[], int key[], int ndim){
int dir, dirold;
double dtime = start_timing();
dirold = MILC_DIR; /* Start from MILC layout */
for(dir = 0; dir < ndim; dir++){
if(key[dir] != 0){
ft_make_map(dirold, dir);
dirold = dir;
}
}
/* End with the MILC layout */
dir = MILC_DIR;
ft_make_map(dirold, dir);
print_timing(dtime, "make FFTW gathers");
}
opt_oct_t* opt_oct_meet_lincons_array(ap_manager_t* man,
bool destructive, opt_oct_t* o,
ap_lincons0_array_t* array)
{
opt_oct_internal_t* pr =
opt_oct_init_from_manager(man,AP_FUNID_MEET_LINCONS_ARRAY,2*(o->dim+8));
if (!o->closed && !o->m)
/* definitively empty */
return opt_oct_set_mat(pr,o,NULL,NULL,destructive);
else {
bool exact, respect_closure;
int i;
opt_oct_mat_t * oo = o->closed ? o->closed : o->m;
/* can / should we try to respect closure */
respect_closure = (oo==o->closed) && (pr->funopt->algorithm>=0);
int size = 2*(o->dim)*(o->dim + 1);
if (!destructive) oo = opt_hmat_copy(oo,o->dim);
/* go */
#if defined(TIMING)
start_timing();
#endif
bool res = opt_hmat_add_lincons(pr,oo,o->intdim,o->dim,array,&exact,&respect_closure);
#if defined(TIMING)
record_timing(meet_lincons_time);
#endif
if (res) {
/* empty */
if (!destructive) {
opt_hmat_free(oo);
oo = NULL;
}
return opt_oct_set_mat(pr,o,NULL,NULL,destructive);
}
else {
/* exact if octagonal constraints & no conversion error */
if (num_incomplete || !exact) flag_incomplete;
else if (pr->conv) flag_conv;
if (respect_closure) return opt_oct_set_mat(pr,o,NULL,oo,destructive);
else return opt_oct_set_mat(pr,o,oo,NULL,destructive);
}
}
}
void make_fftw_plans(int size, ft_data *ftd){
int ncmp;
int rank, howmany, istride, idist, ostride, odist;
int n[1], inembed[1], onembed[1];
int nxfm;
unsigned flags;
int dir;
double dtime = start_timing();
flags = FFTW_ESTIMATE; /* Could try FFTW_MEASURE */
rank = 1;
/* Number of complex values in a 4D site datum */
ncmp = size/sizeof(complex);
idist = odist = 1;
for(dir = 0; dir < NDIM; dir++)
if(layout[dir] != NULL){
nxfm = layout[dir]->nxfm;
/* The FT dimension */
n[0] = inembed[0] = onembed[0] = nxfm;
/* Number of contiguous complex values per 1D coordinate being
transformed */
howmany = (sites_on_node*ncmp)/nxfm;
ostride = istride = howmany;
fwd_plan[dir] =
fftw_plan_many_dft(rank, n, howmany,
ftd->data, inembed, istride, idist,
ftd->tmp, onembed, ostride, odist,
FFTW_FORWARD, flags);
bck_plan[dir] =
fftw_plan_many_dft(rank, n, howmany,
ftd->data, inembed, istride, idist,
ftd->tmp, onembed, ostride, odist,
FFTW_BACKWARD, flags);
}
print_timing(dtime, "make FFTW plans");
}
void display()
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
start_timing();
SetLighting();
CALL_MEMBER_FN(bunny, bunny.render)();
float timeElapsed = stop_timing();
gTotalFrames++;
gTotalTimeElapsed += timeElapsed;
float fps = gTotalFrames / gTotalTimeElapsed;
char string[1024] = {0};
sprintf(string, "OpenGL Bunny: %0.2f FPS", fps);
glutSetWindowTitle(string);
glutPostRedisplay();
glutSwapBuffers();
}
/**
* @brief Performs a volume analysis.
* @return Zero for success, negative value otherwise.
*/
int analyze(udefrag_job_parameters *jp)
{
ULONGLONG time;
int result;
time = start_timing("analysis",jp);
jp->pi.current_operation = VOLUME_ANALYSIS;
/* update volume information */
result = get_volume_information(jp);
if(result < 0)
return result;
/* scan volume for free space areas */
if(get_free_space_layout(jp) < 0)
return (-1);
/* redraw mft zone in light magenta */
get_mft_zones_layout(jp);
/* search for files */
if(find_files(jp) < 0)
return (-1);
/* redraw well known locked files in green */
redraw_well_known_locked_files(jp);
/* produce list of fragmented files */
produce_list_of_fragmented_files(jp);
(void)check_fragmentation_level(jp); /* for debugging */
result = check_requested_action(jp);
if(result < 0)
return result;
jp->p_counters.analysis_time = winx_xtime() - time;
stop_timing("analysis",time,jp);
return 0;
}
void ft_create_layouts(ft_layout *ftl[], ft_layout **ft_milc,
int ndim, int dims[], int key[]){
int dir;
int dtime = start_timing();
/* Set up the FT layout structure for each dir needed */
/* We don't remake the FT layout if it already exists, i.e. the
pointer is nonnull. This provision allows a user to call
setup_restrict_fourier multiple times without risking a memory
leak */
for(dir = 0; dir < ndim; dir++)
if(ftl[dir] == NULL && key[dir] != 0){
ftl[dir] = ft_create_ft_layout(ndim);
ft_setup_layout(ftl[dir]->nsquares, ftl[dir]->squaresize,
ftl[dir]->dirp, ndim, dims, dir);
ftl[dir]->node_number = ft_node_number;
ftl[dir]->node_index = ft_node_index;
ftl[dir]->get_coords = ft_get_coords;
ftl[dir]->nxfm = dims[dir];
}
/* Set up the MILC layout structure */
if(*ft_milc == NULL){
*ft_milc = ft_create_ft_layout(ndim);
/* Copy in the current MILC hypercubic layout dimensions and
function pointers */
ft_fill_milc_layout((*ft_milc)->nsquares, (*ft_milc)->squaresize,
(*ft_milc)->dirp, ndim, dims);
(*ft_milc)->node_number = milc_node_number;
(*ft_milc)->node_index = milc_node_index;
(*ft_milc)->get_coords = milc_get_coords;
(*ft_milc)->nxfm = 0; /* We don't run transforms with the MILC layout */
}
print_timing(dtime, "create FFT layouts");
}
