int
main(int argc, char *argv[])
{
struct itimerspec new_value;
int max_exp, fd;
struct timespec now;
uint64_t exp, tot_exp;
ssize_t s;
if ((argc != 2) && (argc != 4)) {
fprintf(stderr, "%s init-secs [interval-secs max-exp]\n",
argv[0]);
exit(EXIT_FAILURE);
}
if (clock_gettime(CLOCK_REALTIME, &now) == -1)
handle_error("clock_gettime");
/* Create a CLOCK_REALTIME absolute timer with initial
expiration and interval as specified in command line */
double a = 1000.100;
double re = a % 100;
printf("1000.100 % 100 = %lld", re);
new_value.it_value.tv_sec = now.tv_sec + atoi(argv[1]);
new_value.it_value.tv_nsec = now.tv_nsec;
if (argc == 2) {
new_value.it_interval.tv_sec = 0;
max_exp = 1;
} else {
new_value.it_interval.tv_sec = atoi(argv[2]);
max_exp = atoi(argv[3]);
}
new_value.it_interval.tv_nsec = 0;
fd = timerfd_create(CLOCK_REALTIME, 0);
if (fd == -1)
handle_error("timerfd_create");
if (timerfd_settime(fd, TFD_TIMER_ABSTIME, &new_value, NULL) == -1)
handle_error("timerfd_settime");
print_elapsed_time();
printf("timer started\n");
//for (tot_exp = 0; tot_exp < max_exp;) {
s = read(fd, &exp, sizeof(uint64_t));
if (s != sizeof(uint64_t))
handle_error("read");
tot_exp += exp;
print_elapsed_time();
printf("read: %llu; total=%llu\n",
(unsigned long long) exp,
(unsigned long long) tot_exp);
//}
exit(EXIT_SUCCESS);
}
void timeInfo(INT64 *start, INT64 *end, std::string message) {
*start = *end;
*end = get_ticks();
#ifdef TEST_TIME
std::cout << message << ": ";
print_elapsed_time(*start, *end);
std::cout << std::endl;
#endif
}
inline void run_function(Function f, const char* operation_name, int* arg = NULL) {
printf("-------------------------------------------\n");
start_clock();
double pi = f(arg);
if (arg) {
printf("%d - ", *(int*)arg);
}
printf("PI: %15.12f\n", pi);
print_elapsed_time(operation_name);
}
int main(int argc, char* argv[])
{
#ifdef IS_PARALLEL
mpi::environment env(argc, argv);
mpi::communicator world;
#ifdef TEST_OUTPUT
printf ("I am process %d\n", world.rank ());
#endif
#endif
int2D* matrix; /* matrix to fill */
int nr, nc; /* matrix size */
real base_x, base_y;
real ext_x, ext_y;
nr = MAXEXT;
nc = MAXEXT;
base_x = 0;
base_y = 0;
ext_x = 1.5;
ext_y = 1.5;
matrix = new int2D[MAXEXT];
#ifdef TEST_TIME
INT64 start, end;
start = get_ticks ();
#endif
#ifdef IS_PARALLEL
mandel_mpi (world, matrix, nr, nc, base_x, base_y, ext_x, ext_y);
#else
mandel (matrix, nr, nc, base_x, base_y, ext_x, ext_y);
#endif
#ifdef TEST_TIME
end = get_ticks ();
print_elapsed_time (start, end);
#endif
#ifdef TEST_OUTPUT
printf ("Mandelbrot set:\n");
print_matrix (matrix, nr, nc);
#endif
delete [] matrix;
return 0;
}
int main(int argc, char* argv[])
{
#ifdef IS_PARALLEL
mpi::environment env(argc, argv);
mpi::communicator world;
#ifdef TEST_OUTPUT
printf ("I am process %d\n", world.rank ());
#endif
#endif
int2D* matrix; /* to fill */
int nr; /* row size */
int nc; /* column size */
unsigned int limit; /* value limit */
unsigned int seed; /* RNG seed */
nr = MAXEXT;
nc = MAXEXT;
limit = 10;
seed = 222;
matrix = new int2D[MAXEXT];
#ifdef TEST_TIME
INT64 start, end;
start = get_ticks ();
#endif
#ifdef IS_PARALLEL
randmat_mpi (world, matrix, nr, nc, limit, seed);
#else
randmat (matrix, nr, nc, limit, seed);
#endif
#ifdef TEST_TIME
end = get_ticks ();
print_elapsed_time (start, end);
#endif
#ifdef TEST_OUTPUT
print_matrix (matrix, nr, nc);
#endif
delete [] matrix;
return 0;
}
void CowichanSerial::winnow(IntMatrix matrix, BoolMatrix mask,
PointVector points) {
index_t r, c;
index_t len; // number of points
index_t stride; // selection stride
index_t i, j;
// count set cell
len = mask_count (mask, nr, nc);
if (len < n) {
not_enough_points();
}
WeightedPointVector weightedPoints = NULL;
try {
weightedPoints = NEW_VECTOR_SZ(WeightedPoint, len);
}
catch (...) {out_of_memory();}
// fill temporary vector
i = 0;
for (r = 0; r < nr; r++) {
for (c = 0; c < nc; c++) {
if (MATRIX_RECT(mask, r, c)) {
weightedPoints[i++] = WeightedPoint((real)c, (real)r,
MATRIX_RECT(matrix, r, c));
}
}
}
#ifdef SORT_TIME
INT64 start, end;
start = get_ticks ();
#endif
// sort
std::sort(weightedPoints, &weightedPoints[len]);
#ifdef SORT_TIME
end = get_ticks ();
#endif
// copy over points
stride = len / n;
for (i = n - 1, j = len - 1; i >= 0; i--, j -= stride) {
#ifdef WINNOW_OUTPUT
std::cout << weightedPoints[j].weight << "\n";
#endif
points[i] = weightedPoints[j].point;
}
#ifdef SORT_TIME
std::cout << "winnow sort: ";
print_elapsed_time(start, end);
std::cout << std::endl;
#endif
delete [] weightedPoints;
}
int
main(int argc, char *argv[])
{
struct itimerspec new_value;
int max_exp, fd;
struct timespec now;
uint64_t exp, tot_exp;
ssize_t s;
if ((argc != 2) && (argc != 4)) {
fprintf(stderr, "%s init-secs [interval-secs max-exp]\n",
argv[0]);
exit(EXIT_FAILURE);
}
if (clock_gettime(CLOCK_REALTIME, &now) == -1)
handle_error("clock_gettime");
/* Create a CLOCK_REALTIME absolute timer with initial
expiration and interval as specified in command line */
new_value.it_value.tv_sec = now.tv_sec + atoi(argv[1]);
new_value.it_value.tv_nsec = now.tv_nsec;
if (argc == 2) {
new_value.it_interval.tv_sec = 0;
max_exp = 1;
} else {
new_value.it_interval.tv_sec = atoi(argv[2]);
max_exp = atoi(argv[3]);
}
new_value.it_interval.tv_nsec = 0;
fd = timerfd_create(CLOCK_REALTIME, 0);
if (fd == -1)
handle_error("timerfd_create");
if (timerfd_settime(fd, TFD_TIMER_ABSTIME, &new_value, NULL) == -1)
handle_error("timerfd_settime");
print_elapsed_time();
printf("timer started\n");
for (tot_exp = 0; tot_exp < max_exp;) {
#if 0
s = read(fd, &exp, sizeof(uint64_t));
if (s != sizeof(uint64_t))
handle_error("read");
tot_exp += exp;
print_elapsed_time();
printf("read: %llu; total=%llu\n",
(unsigned long long) exp,
(unsigned long long) tot_exp);
#endif
fd_set rfds;
struct timeval tv;
int retval;
tv.tv_sec = 5;
tv.tv_usec = 0;
FD_ZERO(&rfds);
FD_SET(fd, &rfds);
retval = select(fd + 1, &rfds, NULL, NULL, &tv);
printf("%d %d\n", retval, read(fd, &exp, sizeof(uint64_t)));
}
exit(EXIT_SUCCESS);
}
int main(int argc, char* argv[])
{
#ifdef IS_PARALLEL
mpi::environment env(argc, argv);
mpi::communicator world;
#ifdef TEST_OUTPUT
printf ("I am process %d\n", world.rank ());
#endif
#endif
int2D* matrix;
bool2D* mask;
int nr, nc;
real fraction;
int i, j;
int limit;
nr = MAXEXT;
nc = MAXEXT;
limit = 10;
fraction = 0.5;
srand (222);
matrix = new int2D[MAXEXT];
for (i = 0; i < nr; i++) {
for (j = 0; j < nc; j++) {
matrix[i][j] = rand () % limit;
}
}
mask = new bool2D[MAXEXT];
#ifdef TEST_OUTPUT
printf ("Matrix is:\n");
print_matrix (matrix, nr, nc);
#endif
#ifdef TEST_TIME
INT64 start, end;
start = get_ticks ();
#endif
#ifdef IS_PARALLEL
thresh_mpi (world, matrix, mask, nr, nc, fraction);
#else
thresh (matrix, mask, nr, nc, fraction);
#endif
#ifdef TEST_TIME
end = get_ticks ();
print_elapsed_time (start, end);
#endif
#ifdef TEST_OUTPUT
printf ("Mask is:\n");
print_matrix (mask, nr, nc);
#endif
delete [] matrix;
delete [] mask;
return 0;
}
int main(int argc, char* argv[])
{
#ifdef IS_PARALLEL
mpi::environment env(argc, argv);
mpi::communicator world;
#ifdef TEST_OUTPUT
printf ("I am process %d\n", world.rank ());
#endif
#endif
real2D* matrix; /* to multiply by */
real1D* vector; /* to be multiplied */
real1D* result; /* result of multiply */
int nr; /* row size */
int nc; /* column size */
int limit;
int i, j;
srand (222);
nr = MAXEXT;
nc = MAXEXT;
limit = 10;
matrix = new real2D[MAXEXT];
for (i = 0; i < nr; i++)
{
for (j = 0; j < nc; j++)
{
matrix[i][j] = (real) (rand () % limit);
}
}
vector = new real1D[MAXEXT];
for (i = 0; i < nr; i++)
{
vector[i] = (real) (rand () % limit);
}
result = new real1D[MAXEXT];
#ifdef TEST_OUTPUT
printf ("Matrix\n");
print_matrix (matrix, nr, nc);
printf ("x Vector\n");
print_vector (vector, nr);
#endif
#ifdef TEST_TIME
INT64 start, end;
start = get_ticks ();
#endif
#ifdef IS_PARALLEL
product_mpi (world, matrix, vector, result, nr, nc);
#else
product (matrix, vector, result, nr, nc);
#endif
#ifdef TEST_TIME
end = get_ticks ();
print_elapsed_time (start, end);
#endif
#ifdef TEST_OUTPUT
printf ("=\n");
print_vector (result, nr);
#endif
delete [] matrix;
delete [] vector;
delete [] result;
return 0;
}
int main(int argc, char **argv) {
init_needle(argc > 1 ? argv[1] : "GCAACGAGTGTCTTTG");
#ifdef DNA_DEBUG
printf("Looking for %s\n", needle);
#endif
struct timeval start_time;
print_current_time(&start_time);
printf(" START\n");
bufindex_t input_size = 3000000000L;
size_t page_size = sysconf(_SC_PAGESIZE);
ASSERT_NOT(page_size & (page_size - 1), "Page is not a power of 2");
size_t mask = page_size - 1;
size_t mem_size = (input_size | mask) + 1;
buflen_t buf_size = page_size << 14;
#ifdef DNA_DEBUG
printf("Buf size = %u\n", buf_size);;
#endif
init_threads();
ALGO_PREPARE
#ifdef DNA_DEBUG
long io_time, waiting_time;
struct timeval tx, ty, tz;
print_current_time(&tx);
printf(" Start reading data\n");
#endif
int fd = 0;
if (argc > 2 && (fd = open(argv[2], O_RDONLY)) == -1) ERROR_OCCURRED("open");
char *mapped_file = mmap(NULL, mem_size, PROT_READ, MAP_SHARED, fd, 0);
if (fd > 0 && close(fd) == -1) ERROR_OCCURRED("close");
char *buf;
bufindex_t start;
buflen_t bytes_read;
buflen_t len = buf_size + needle_len - 1;
for (start = 0, buf = mapped_file; start < input_size; start += buf_size, buf += buf_size) {
bytes_read = (start + len < input_size) ? len : input_size - start;
job_t *job = malloc(sizeof(job_t));
job->buf = buf;
job->len = bytes_read;
job->offset = start;
submit_job(job);
}
#ifdef DNA_DEBUG
print_current_time(&ty);
printf(" End submitting jobs\n");
io_time = calc_elapsed_time(&tx, &ty);
#endif
wait_jobs_completed();
munmap(mapped_file, mem_size);
#ifdef DNA_DEBUG
gettimeofday(&tz, NULL);
waiting_time = calc_elapsed_time(&ty, &tz);
#endif
destroy_threads();
ALGO_FREE
struct timeval end_time;
print_current_time(&end_time);
printf(" FINISH\n");
#ifdef DNA_DEBUG
print_elapsed_time(&start_time, &end_time);
printf("I/O: %ld\n", io_time);
printf("Waiting: %ld\n", waiting_time);
#endif
return 0;
}
int main()
{
int i,j,k,mult[10][10],r1,c1,r2,c2, b[10],c[10];
printf("===========================================================\n");
printf("NAIVE MATRIX MULTIPLICATION\n");
printf("=============================================================\n");
/*printf("Enter number of rows and columns of first matrix (less than 10)\n");
scanf("%d%d",&r1,&c1);
printf("Enter number of rows and columns of second matrix (less than 10)\n");
scanf("%d%d",&r2,&c2);
if(r2==c1)
{
printf("Enter rows and columns of First matrix \n");
printf("Row wise\n");
for(i=0;i<r1;i++)
for(j=0;j<c1;j++)
scanf("%d",&m1[i][j]);
*/
r1=r2=c1=c2=2;
int m1[2][2]={1,1,1,1};
int m2[2][2]={2,2,2,2};
printf("First Matrix is :\n");
for(i=0;i<r1;i++)
{
for(j=0;j<c1;j++)
printf("%d\t",m1[i][j]);
printf("\n");
}
/* printf("Enter rows and columns of Second matrix \n");
printf("Row wise\n");
for(i=0;i<r2;i++)
for(j=0;j<c2;j++)
scanf("%d",&m2[i][j]);
*/
printf("Second Matrix is:\n");
for(i=0;i<r2;i++)
{
for(j=0;j<c2;j++)
printf("%d\t",m2[i][j]);
printf("\n");
}
printf("Multiplication of the Matrices:\n");
for(i=0;i<r1;i++)
{
for(j=0;j<c2;j++)
{
mult[i][j]=0;
for(k=0;k<r1;k++)
{
mult[i][j]+=m1[i][k]*m2[k][j];
for(int t=0;t<30000;t++)
{
printf("");
}
}
printf("%d\t",mult[i][j]);
}
printf("\n");
}
print_elapsed_time();
getch();
}
void timer_handler(int signum)
{
fflush(NULL);
print_elapsed_time();
}
int main(int c, char *v[])
{
// process input arguments
if (c < 2) {
print_help(v);
return 1;
}
// optional arguments
const char *output_file = pick_option(&c, &v, "o", "stdout");
bool binary = (bool) pick_option(&c, &v, "b", NULL);
bool verbose = (bool) pick_option(&c, &v, "-verbose", NULL);
int max_nb_pts = atoi(pick_option(&c, &v, "-max-nb-pts", "INT_MAX"));
float thresh_dog = atof(pick_option(&c, &v, "-thresh-dog", "0.0133"));
int ss_noct = atoi(pick_option(&c, &v, "-scale-space-noct", "8"));
int ss_nspo = atoi(pick_option(&c, &v, "-scale-space-nspo", "3"));
// initialise time
struct timespec ts; portable_gettime(&ts);
// define the rectangular region of interest (roi)
int x, y, w, h;
if (c == 2) {
x = 0;
y = 0;
} else if (c == 6) {
x = atoi(v[2]);
y = atoi(v[3]);
w = atoi(v[4]);
h = atoi(v[5]);
} else {
print_help(v);
return 1;
}
// read the roi in the input image
GDALDatasetH hDataset;
GDALAllRegister();
hDataset = GDALOpen( v[1], GA_ReadOnly );
if( hDataset == NULL )
{
fprintf(stderr, "ERROR : can't open %s\n", v[1]);
}
GDALRasterBandH hBand;
hBand = GDALGetRasterBand( hDataset, 1 );
float *roi;
roi = (float *) CPLMalloc(sizeof(float)*w*h);
GDALRasterIO( hBand, GF_Read, x, y, w, h,
roi, w, h, GDT_Float32,
0, 0 );
GDALClose(hBand);
GDALClose(hDataset);
if (verbose) print_elapsed_time(&ts, "read ROI", 35);
// prepare sift parameters
struct sift_parameters* p = sift_assign_default_parameters();
p->C_DoG = thresh_dog;
p->n_oct = ss_noct;
p->n_spo = ss_nspo;
// compute sift keypoints
struct sift_scalespace **ss = (struct sift_scalespace**) malloc(4 * sizeof(struct sift_scalespace*));
struct sift_keypoints **kk = (struct sift_keypoints**) malloc(6 * sizeof(struct sift_keypoints*));
for (int i = 0; i < 6; i++)
kk[i] = sift_malloc_keypoints();
struct sift_keypoints* kpts = sift_anatomy(roi, w, h, p, ss, kk);
if (verbose) print_elapsed_time(&ts, "run SIFT", 35);
// add (x, y) offset to keypoints coordinates
for (int i = 0; i < kpts->size; i++) {
kpts->list[i]->x += y; // in Ives' conventions x is the row index
kpts->list[i]->y += x;
}
if (verbose) print_elapsed_time(&ts, "add offset", 35);
// write to standard output
FILE *f = fopen(output_file, "w");
fprintf_keypoints(f, kpts, max_nb_pts, binary, 1);
fclose(f);
if (verbose) print_elapsed_time(&ts, "write output", 35);
// cleanup
CPLFree(roi);
sift_free_keypoints(kpts);
for (int i = 0; i < 6; i++)
sift_free_keypoints(kk[i]);
free(kk);
for (int i = 0; i < 4; i++)
sift_free_scalespace(ss[i]);
free(ss);
free(p);
return 0;
}
int main()
{
SHA256_CTX md_ctx;
AES_KEY key;
_AES_CTX ctx;
uint8_t buf[64], nb[32], enb[32];
int i, len;
int nk = BITS >> 5, nr = 6 + nk, key_nb = (nr + 1) * AES_NB * 4;
FILE *fp, *ofp;
struct timeval tv_start, tv_end;
for (len = 0; len < 64; len += 32) {
SHA256_Init(&md_ctx);
if (len == 0) {
SHA256_Update(&md_ctx, KEY, strlen(KEY));
SHA256_Final(buf, &md_ctx);
} else {
SHA256_Update(&md_ctx, buf + len - 32, 32);
SHA256_Update(&md_ctx, KEY, strlen(KEY));
SHA256_Final(buf + len, &md_ctx);
}
}
AES_set_encrypt_key(buf, BITS, &key);
hex_dump((uint8_t *)key.rd_key, key_nb);
expand_key(&(ctx.key), buf, BITS);
ctx.encrypt = _AES_ecb_encrypt;
ctx.decrypt = _AES_ecb_decrypt;
hex_dump(ctx.key.rd_key, key_nb);
for (i = 0; i < 32; i++)
nb[i] = '\0';
gettimeofday(&tv_start, NULL);
for (i = 0; i < 1024; i++)
AES_encrypt(nb, enb, &key);
gettimeofday(&tv_end, NULL);
print_elapsed_time(&tv_start, &tv_end);
hex_dump(enb, 16);
gettimeofday(&tv_start, NULL);
for (i = 0; i < 1024; i++)
ctx.encrypt(nb, enb, &ctx);
gettimeofday(&tv_end, NULL);
print_elapsed_time(&tv_start, &tv_end);
hex_dump(enb, 16);
for (i = 0; i < 32; i++)
nb[i] = enb[i];
ctx.decrypt(nb, enb, &ctx);
hex_dump(enb, 16);
if ((fp = fopen("test.bin", "r")) == NULL) {
fprintf(stderr, "File open failed\n");
exit(-1);
}
while (!feof(fp)) {
if (fread(nb, 1, _AES_BLOCK_SIZE, fp) == 0) {
fprintf(stderr, "Failed in call to fread()\n");
exit(-1);
}
}
fseek(fp, 0, SEEK_SET);
i = 0;
gettimeofday(&tv_start, NULL);
while (!feof(fp)) {
++i;
if (fread(nb, 1, _AES_BLOCK_SIZE, fp) == 0) {
fprintf(stderr, "Failed in call to fread()\n");
exit(-1);
}
AES_encrypt(nb, enb, &key);
}
gettimeofday(&tv_end, NULL);
print_elapsed_time(&tv_start, &tv_end);
printf("blocks = %d\n", i);
fseek(fp, 0, SEEK_SET);
i = 0;
gettimeofday(&tv_start, NULL);
while (!feof(fp)) {
++i;
if (fread(nb, 1, _AES_BLOCK_SIZE, fp) == 0) {
fprintf(stderr, "Failed in call to fread()\n");
exit(-1);
}
ctx.encrypt(nb, enb, &ctx);
}
gettimeofday(&tv_end, NULL);
print_elapsed_time(&tv_start, &tv_end);
printf("blocks = %d\n", i);
fclose(fp);
fp = fopen("test.enc", "r");
ofp = fopen("tmp.bin", "w");
ctx.encrypt = _AES_cbc_encrypt;
ctx.decrypt = _AES_cbc_decrypt;
memcpy(ctx.ivec, buf + 32, _AES_BLOCK_SIZE);
while (!feof(fp)) {
if (fread(nb, 1, _AES_BLOCK_SIZE, fp) == 0) {
fprintf(stderr, "Failed in call to fread()\n");
exit(-1);
}
ctx.decrypt(nb, enb, &ctx);
fwrite(enb, 1, _AES_BLOCK_SIZE, ofp);
}
fclose(fp);
fclose(ofp);
return 0;
}
