int main(int argc, char *argv[])
{
int n;
int size;
prog_name = argv[0];
if (argc != 4) {
printf("%s: %s num size dir\n", prog_name, prog_name);
exit(1);
}
n = atoi(argv[1]);
size = atoi(argv[2]);
topdir = argv[3];
printf("%s %d %d %s\n", prog_name, n, size, topdir);
creat_dir();
printstats(topdir, 1);
creat_test(n, size);
printstats(topdir, 0);
read_test(n, size);
delete_test(n);
unlink("t");
return 0;
}
void run_tests(int iter)
{
testno = 1;
snprintf(dirent_name, OCFS2_MAX_FILENAME_LEN,
"multi-indexed-dirs-test-%d", iter);
snprintf(dir_name, OCFS2_MAX_FILENAME_LEN, "%s/%s", work_place,
dirent_name);
if (test_flags & GROW_TEST)
grow_test();
if (test_flags & RENM_TEST)
rw_test();
if (test_flags & READ_TEST)
read_test();
if (test_flags & ULNK_TEST)
unlink_test();
if (test_flags & FLUP_TEST)
fillup_test();
if (test_flags & STRS_TEST)
stress_test();
}
int main()
{
/* write a PLY file */
write_test();
/* read a PLY file */
read_test();
}
/*
* Test routines
*/
void
test_read(
int max)
{
int i, ssk, usecs;
struct timeval start, stop;
if (max == 0)
max = test_read_skew + 1;
ssk = test_read_skew;
for (i = test_read_skew_min; i < max; i++){
test_read_skew = i;
start = time;
read_test();
stop = time;
usecs = stop.tv_usec - start.tv_usec;
if (usecs < 0) {
stop.tv_sec -= 1;
usecs += 1000000;
}
printf("Skew %3d size %d count %d time %3d sec %d us\n",
i, test_read_size, test_read_nreads,
stop.tv_sec - start.tv_sec, usecs);
}
test_read_skew = ssk;
}
int
main(int argc, char *argv[])
{
int ret = 0;
if (argc != 2) {
printf("Usage: %s [getattr|readdir|open|read]\n", argv[0]);
ret = 1;
goto out;
}
pagesize = getpagesize();
if (strcmp(argv[1], "getattr") == 0) {
ret = getattr_test();
} else if (strcmp(argv[1], "readdir") == 0) {
ret = readdir_test();
} else if (strcmp(argv[1], "open") == 0) {
ret = open_test();
} else if (strcmp(argv[1], "read") == 0) {
ret = read_test();
} else if (strcmp(argv[1], "write") == 0) {
ret = write_test();
} else if (strcmp(argv[1], "remove") == 0) {
ret = remove_test();
}else if (strcmp(argv[1], "mkdir") == 0) {
ret = mkdir_test();
}else if (strcmp(argv[1], "rmdir") == 0) {
ret = rmdir_test();
}
out:
exit(ret);
}
TEST_CASE PlotReaderTest()
{
TEST(read_test("../DemoData/index", "fred", 10.0) > 0);
epicsTime start;
TEST(string2epicsTime("03/23/2004 10:50:00", start));
TEST(read_test("../DemoData/index", "fred", 10.0, &start) > 0);
epicsTime end(start);
end += 15;
TEST(read_test("../DemoData/index", "fred", 5.0, &start, &end) > 0);
TEST(DataFile::clear_cache() == 0);
TEST_OK;
}
int main(){
FILE* f = fopen ("test_output6.txt", "w");
int size;
int sizeOfRegion = 1 << 20;// 1MB
int a = psumeminit(1, sizeOfRegion);
if (a == -1){
fprintf(f, "Initialization failed!\n");
}
void* pointer_array[16][NUM];
for (int i = 0; i < 16; i++){
for (int j = 0; j < NUM; j++){
pointer_array[i][j] = NULL;
}
}
for (int i = 0; i < 16; i++){
for (int j = 0; j < NUM; ++j)
{
size = rand()%248 + 8;
test* a = (test*)psumalloc(size);
write_test(a);
read_test(a, f);
if (a == NULL){
fprintf(f, "No. %d: No extra space for allocation in memory!\n", j);
}
else{
pointer_array[i][j] = a;
fprintf(f, "NO.%d chunk has been allocated, the size is %d bytes\n", j, size);
}
}
}
int half = 16;
while (half != 0){
half /= 2;
int bound;
if (half){
bound = half * 2;
}
else{
bound = 1;
}
for (int i = half; i < bound ; i++){
for (int j = 0; j < NUM; j++)
{
int a = psufree(pointer_array[i][j]);
if (a == 0){
fprintf(f, "No.%d chunk has been freed. \n", j);
}
else{
fprintf(f, "Can not free No.%d chunk. \n", j);
}
}
}
}
fclose(f);
return 0;
}
int main(int argc, char *argv[])
{
int n, fd;
int size;
prog_name = argv[0];
if (argc != 4) {
printf("%s: %s num size fsync\n", prog_name, prog_name);
exit(1);
}
n = atoi(argv[1]);
size = atoi(argv[2]);
do_fsync = atoi (argv[3]);
if (do_fsync != 0 && do_fsync != 1) {
printf("%s: fsync 0 or 1!\n", prog_name);
exit (1);
}
printf("\n%s %d %d\n", prog_name, n, size);
srandom(getpid());
if((fd = creat(name, S_IRUSR | S_IWUSR)) < 0) {
printf("%s: create %d failed %d\n", prog_name, fd, errno);
exit(1);
}
close (fd);
flush_cache ();
write_test(n, size, 1);
read_test(n, size, 1);
write_test(n , size, 0);
read_test(n, size, 0);
read_test(n , size, 1);
unlink(name);
return 0;
}
void run_tests(void) {
int i = 0;
read_test(100, 8192);
read_test(10000, 8192);
read_test(10000, 137);
read_test(10000, 1);
large_read_test(8192);
large_read_test(1);
write_test(100, 8192);
write_test(100, 1);
write_test(100000, 8192);
write_test(100000, 1);
write_test(100000, 137);
for (i = 1; i < 1000; i = GPR_MAX(i + 1, i * 5 / 4)) {
write_test(40320, i);
}
}
TEST_CASE RawDataReaderTest()
{
TEST(read_test("../DemoData/index", "fred") == 87);
epicsTime start;
TEST(string2epicsTime("03/23/2004 10:50:42.400561000", start));
TEST(read_test("../DemoData/index", "fred", &start) == 10);
#ifdef CHECK_AUTO_INDEX
TEST(auto_read_test("../DemoData/index", "fred", &start) == 10);
TEST(auto_read_test("list_index.xml", "fred", &start) == 10);
#endif
epicsTime end(start);
end += 5;
TEST(read_test("../DemoData/index", "fred", &start, &end) == 3);
#ifdef CHECK_AUTO_INDEX
TEST(auto_read_test("../DemoData/index", "fred", &start, &end) == 3);
TEST(auto_read_test("list_index.xml", "fred", &start, &end) == 3);
#endif
TEST(DataFile::clear_cache() == 0);
TEST_OK;
}
main()
{
#if 1
/* write a PLY file */
write_test();
#endif
#if 1
/* read a PLY file */
read_test();
#endif
}
/*
* Test whether writing to counter works.
*/
static void write_test(int fd)
{
int ret;
uint64_t val;
val = 12;
ret = set_counter(fd, val);
if (ret == -1) {
tst_resm(TBROK, "error setting counter value to %" PRIu64, val);
return;
}
read_test(fd, val);
}
int main(int argc, char **argv)
{
int lc;
int fd;
tst_parse_opts(argc, argv, NULL, NULL);
setup();
for (lc = 0; TEST_LOOPING(lc); lc++) {
int ret;
uint64_t einit = 10;
tst_count = 0;
fd = myeventfd(einit, 0);
if (fd == -1)
tst_brkm(TBROK | TERRNO, CLEANUP,
"error creating eventfd");
ret = fcntl(fd, F_SETFL, O_NONBLOCK);
if (ret == -1)
tst_brkm(TBROK | TERRNO, CLEANUP,
"error setting non-block mode");
read_test(fd, einit);
read_eagain_test(fd);
write_test(fd);
write_eagain_test(fd);
read_einval_test(fd);
write_einval_test(fd);
write_einval2_test(fd);
readfd_set_test(fd);
readfd_not_set_test(fd);
writefd_set_test(fd);
writefd_not_set_test(fd);
child_inherit_test(fd);
overflow_select_test(fd);
overflow_poll_test(fd);
overflow_read_test(fd);
close(fd);
}
cleanup();
tst_exit();
}
void main(int argc, char *argv[])
{
int opt;
unsigned char write_enable = 0;
char *device = NULL;
unsigned int blocks = 0;
int blocksize = 1024;
int repeats = 1;
printf("RetroDisk Profiler\n");
while((opt = getopt(argc,argv,"wd:b:s:r:"))!=-1)
{
switch(opt)
{
case 'w':
printf("Write tests enabled!\n");
write_enable=1;
break;
case 'd':
device = optarg;
break;
case 'b':
blocks = atoi(optarg);
break;
case 's':
blocksize = atoi(optarg);
break;
case 'r':
repeats = atoi(optarg);
break;
}
}
if(device==NULL)
{
usage();
}
read_test(device,blocks,blocksize,repeats);
if(write_enable==1)
write_test(device,blocks,blocksize,repeats);
}
int main(){
FILE* f = fopen ("test_output8.txt", "w");
int size;
int sizeOfRegion = 1 << 20;// 1MB
int a = psumeminit(1, sizeOfRegion);
if (a == -1){
fprintf(f, "Initialization failed!\n");
}
for (int i = 0; i < 10; i++){
void* pointer_array[NUM];
for (int i = 0; i < NUM; ++i){
pointer_array[i] = NULL;
}
for (int i = 0; i < NUM; ++i)
{
size = rand()%248 + 8;
test* a = (test*)psumalloc(size);
write_test(a);
read_test(a, f);
if (a == NULL){
fprintf(f, "No.%d : No extra space for allocation in memory!\n", i);
}
else{
pointer_array[i] = a;
fprintf(f, "NO.%d chunk has been allocated. the size is %d bytes \n", i, size);
}
}
for (int i = 0; i < NUM; ++i)
{
int a = psufree(pointer_array[i]);
if (a == 0){
fprintf(f, "No.%d chunk has been freed. \n", i);
}
else{
fprintf(f, "Can not free No.%d chunk. \n", i);
}
}
}
fclose(f);
return 0;
}
int mymain()
{
unsigned char c = 68;
//clock_init();
uart_init();
// 初始化nandflash
nand_init();
while (1)
{
printf("\r\n********Nandflash R/W Test*******\r\n");
printf("[i] Read ID\r\n");
printf("[e] Erase Nandflash\r\n");
printf("[w] Write Nandflash\r\n");
printf("[r] Read Nandflash\r\n");
printf("[n] read sdram to nand\r\n");
printf("Enter your choice: ");
c = getc();
printf("%c\r\n",c);
switch(c)
{
case 'i':
nand_read_id();
break;
case 'e':
erase_test();
break;
case 'w':
write_test();
break;
case 'r':
read_test();
break;
case 'n':
sdram_to_nand_test();
break;
}
}
return 0;
}
static int /* O - Standard input of child */
run_read_test(void)
{
int ras_pipes[2]; /* Raster data pipes */
int pid; /* Child process ID */
if (pipe(ras_pipes))
return (-1);
if ((pid = fork()) < 0)
{
/*
* Fork error - return -1 on error...
*/
close(ras_pipes[0]);
close(ras_pipes[1]);
return (-1);
}
else if (pid == 0)
{
/*
* Child comes here - read data from the input pipe...
*/
close(ras_pipes[1]);
read_test(ras_pipes[0]);
exit(0);
}
else
{
/*
* Parent comes here - return the output pipe...
*/
close(ras_pipes[0]);
return (ras_pipes[1]);
}
}
XAttrManager::XAttrManager(const Glib::ustring& filename) throw (XAttrManagerException)
: _filename(filename)
{
// Check it is an ordinary file or a directory
struct stat buffer;
if (stat(_filename.c_str(), &buffer) == -1)
{
throw XAttrManagerException(Glib::locale_to_utf8(strerror(errno)));
}
if (!S_ISREG(buffer.st_mode) && !S_ISDIR(buffer.st_mode))
{
throw XAttrManagerException(_("Only regular files or directories supported"));
}
this->_owner = buffer.st_uid;
// FIXME Crappy way to detect if we can modify xattrs,
// it will thrown a exception if they cannot be read
read_test();
}
static int worker_run(struct worker *self)
{
char buf[BUFFER_SIZE];
struct sigaction term_sa = {
.sa_handler = SIG_IGN,
.sa_flags = 0,
};
struct queue *q = self->q;
sigaction(SIGTTIN, &term_sa, NULL);
while (1) {
if (!queue_pop(q, buf))
break;
read_test(buf);
}
queue_destroy(q, 1);
tst_flush();
return 0;
}
static void spawn_workers(void)
{
int i;
struct worker *wa = workers;
bzero(workers, worker_count * sizeof(*workers));
for (i = 0; i < worker_count; i++) {
wa[i].q = queue_init();
wa[i].pid = SAFE_FORK();
if (!wa[i].pid)
exit(worker_run(wa + i));
}
}
int main(int argc, char **argv)
{
/* 初期値設定 c getopt用変数 size サイズ(1048576byte)
rcount 読み込み回数(0回) wcount 書き込み回数(0回)
sizesw size option が設定されたかどうかのフラグ
filename ファイルの名前（"/tmp/io-bench.tmp")
st statbuf stat用領域 */
int c;
int size = 1048576;
int rcount = 0;
int wcount = 0;
int sizesw = 0;
char filename[PATH_MAX];
int st;
struct stat statbuf;
/* ファイルサイズ処理関連の変数初期化 */
int mem[4]; /* キロ、メガ、ギガ 用の基数保存用 */
char *ans; /* 文字検索用ポインタ保存域 */
char mainbuff[PATH_MAX]="kKmMgG", findbuff[PATH_MAX]="", sizebuff[PATH_MAX]="";
int x; /* ポインタの場所記憶域 */
strcpy(filename, "/tmp/io-bench.tmp");
mem[1] = 1024;
mem[2] = 1048576;
mem[3] = 1073741824;
/* オプションの設定 r: 読み込みオプション rcount
w: 書き込みオプション wcount
s: サイズオプション size
オプション無し…ファイル名…filename */
while ((c = getopt(argc, argv, "r:w:s:")) > 0) {
switch (c) {
case 'r':
rcount = atoi(optarg);
break;
case 'w':
wcount = atoi(optarg);
break;
case 's':
memmove(sizebuff, optarg, strlen(optarg) - 1);
memmove(findbuff, optarg + strlen(optarg) - 1, 1);
ans = strstr(mainbuff, findbuff);
if (ans != NULL) {
x = (int)(ans - mainbuff) + 2;
x = x / 2;
size = atoi(sizebuff) * mem[x];
}
else {
size = atoi(optarg);
}
sizesw = 1;
break;
default:
printf("io-bench [-r count][-w coount][-s size]");
printf("[dirname | dirname/filename]");
printf("\n\n -r count [count] times read. default 0.");
printf("\n\n -w count [count] times write. default 0.");
printf("\n\n -s size [size] file open. ");
printf("default 1M or filesize\n\n");
printf(" default filename '/tmp/io-bench.tmp'");
printf("\n\n for example './io-bench -r 10 -w 10 -s");
printf(" 1024K /tmp/io-bench.tmp'\n\n");
exit(1);
}
}
/* ファイル名の指定があった場合filenameにファイル名を代入 */
if (optind < argc) {
strcpy(filename, argv[optind++]);
}
/* 指定されたファイルがファイルか、ディレクトリかを判別 */
errno = 0;
st = stat(filename, &statbuf);
if (st == -1) {
if (errno != ENOENT) {
perror(filename);
exit (1);
}
}
else { /* filemodeがディレクトリの場合 ディレクトリ＋/io-bench.tmp */
if (S_ISDIR(statbuf.st_mode)) {
strcat(filename, "/io-bench.tmp");
}
}
/* filename のファイルサイズをサイズに代入（size指定が無い場合） */
st = stat(filename, &statbuf);
if (st == -1) {
}
else {
if (sizesw == 0) {
size = statbuf.st_size;
}
}
/* 書き込み処理、読み込み処理 回数が０の場合実行しない */
if (wcount > 0) {
write_test(wcount, size, filename);
}
if (rcount > 0) {
read_test(rcount, size, filename);
}
return 0;
}
int
main (int argc, char **argv)
{
round_t round = TEST_INITIALIZER;
char *text_filename = make_filename ("t-data-1.txt");
char *longer_text_filename = make_filename ("t-data-2.txt");
const char *missing_filename = "this-file-surely-does-not-exist";
gpgme_error_t err = 0;
gpgme_data_t data;
while (++round)
{
switch (round)
{
case TEST_INVALID_ARGUMENT:
err = gpgme_data_new (NULL);
if (!err)
{
fprintf (stderr, "%s:%d: gpgme_data_new on NULL pointer succeeded "
"unexpectedly\n", __FILE__, __LINE__);
exit (1);
}
continue;
case TEST_INOUT_NONE:
err = gpgme_data_new (&data);
break;
case TEST_INOUT_MEM_NO_COPY:
err = gpgme_data_new_from_mem (&data, text, strlen (text), 0);
break;
case TEST_INOUT_MEM_COPY:
err = gpgme_data_new_from_mem (&data, text, strlen (text), 1);
break;
case TEST_INOUT_MEM_FROM_FILE_COPY:
err = gpgme_data_new_from_file (&data, text_filename, 1);
break;
case TEST_INOUT_MEM_FROM_INEXISTANT_FILE:
err = gpgme_data_new_from_file (&data, missing_filename, 1);
if (!err)
{
fprintf (stderr, "%s:%d: gpgme_data_new_from_file on inexistant "
"file succeeded unexpectedly\n", __FILE__, __LINE__);
exit (1);
}
continue;
case TEST_INOUT_MEM_FROM_FILE_NO_COPY:
err = gpgme_data_new_from_file (&data, text_filename, 0);
/* This is not implemented yet. */
if (gpgme_err_code (err) == GPG_ERR_NOT_IMPLEMENTED
|| gpgme_err_code (err) == GPG_ERR_INV_VALUE)
continue;
break;
case TEST_INOUT_MEM_FROM_FILE_PART_BY_NAME:
err = gpgme_data_new_from_filepart (&data, longer_text_filename, 0,
strlen (text), strlen (text));
break;
case TEST_INOUT_MEM_FROM_INEXISTANT_FILE_PART:
err = gpgme_data_new_from_filepart (&data, missing_filename, 0,
strlen (text), strlen (text));
if (!err)
{
fprintf (stderr, "%s:%d: gpgme_data_new_from_file on inexistant "
"file succeeded unexpectedly\n", __FILE__, __LINE__);
exit (1);
}
continue;
case TEST_INOUT_MEM_FROM_FILE_PART_BY_FP:
{
FILE *fp = fopen (longer_text_filename, "rb");
if (! fp)
{
fprintf (stderr, "%s:%d: fopen: %s\n", __FILE__, __LINE__,
strerror (errno));
exit (1);
}
err = gpgme_data_new_from_filepart (&data, 0, fp,
strlen (text), strlen (text));
}
break;
case TEST_END:
goto out;
case TEST_INITIALIZER:
/* Shouldn't happen. */
fprintf (stderr, "%s:%d: impossible condition\n", __FILE__, __LINE__);
exit (1);
}
fail_if_err (err);
read_test (round, data);
write_test (round, data);
gpgme_data_release (data);
}
out:
free (text_filename);
free (longer_text_filename);
return 0;
}
int main(){
printf("You entered: %d\n", a);
// LSMT parameters from user inputs
int Nc, size, ratio, value_size;
printf("Define the number of components: ");
scanf("%d", &Nc);
printf("Define the size of C0: ");
scanf("%d", &size);
printf("Define the ratio: ");
scanf("%d", &ratio);
printf("Define the value size: ");
scanf("%d", &value_size);
char *name = (char *) malloc(FILENAME_SIZE * sizeof(char));
printf("Define the name of the LSM tree: ");
scanf("%s", name);
// ------------------------ BUILDING THE LSM TREE
int* Cs_size = (int *) malloc((Nc+2) * sizeof(int));
Cs_size[0] = size;
for (int i=1; i<(Nc+2); i++) Cs_size[i] = ratio * Cs_size[i-1];
LSM_tree *lsm = (LSM_tree*) malloc(sizeof(LSM_tree));
// Read test
read_test(lsm, 100);
read_test(lsm, 1000);
read_test(lsm, 10000);
read_test(lsm, 100000);
read_test(lsm, 999999);
read_test(lsm, 1000000);
// ---------------- TEST READING LSM FROM DISK
printf("%d\n",BLOOM_ON);
printf("%d\n",BLOOM_ON);
printf("Reading LSM from disk:\n");
LSM_tree *lsm_backup = (LSM_tree *)malloc(sizeof(LSM_tree));
read_lsm_from_disk(lsm_backup, name, FILENAME_SIZE);
print_state(lsm_backup);
// Read test
read_test(lsm_backup, 100);
read_test(lsm_backup, 1000);
read_test(lsm_backup, 10000);
read_test(lsm_backup, 100000);
read_test(lsm_backup, 999999);
read_test(lsm_backup, 1000000);
// PARALLEL READING TEST
printf("----------------------------------\n");
printf("PARALLEL READS\n");
printf("----------------------------------\n");
read_parallel_test(lsm_backup, 999);
printf("----------------------------------\n");
read_parallel_test(lsm_backup, 9999);
printf("----------------------------------\n");
read_parallel_test(lsm_backup, 51215);
printf("----------------------------------\n");
read_parallel_test(lsm_backup, 215841);
printf("----------------------------------\n");
//update/delete tests
// To store the value to update
char* value = (char*) malloc(lsm_backup->value_size * sizeof(char));
int key = 999;
// Filling the updated value
for (int i=0; i<lsm_backup->value_size - 7; i++) value[i] = 'b';
sprintf(value + lsm_backup->value_size - 7, "_%d", key%10000);
// update_lsm(lsm_backup, key, value);
delete_lsm(lsm_backup, 999);
read_test(lsm_backup, key);
// Wrap up
print_state(lsm_backup);
write_lsm_to_disk(lsm_backup);
free_lsm(lsm_backup);
}
int main () {
// utility parameters
int n, i;
clean_array((int*)count_case_0, 2097152*5);
clean_array((int*)count_case_1, 2097152*5);
// read the train.csv data
FILE *train;
train = fopen ("train.csv", "r");
while (fgetc(train) != '\n') ; // skip the head line
int id, delta, initial_grid[24][24], start_grid[24][24], stop_grid[24][24];
clean_array((int*)initial_grid, 24*24);
clean_array((int*)start_grid, 24*24);
clean_array((int*)stop_grid, 24*24);
// read all the train set and make statistical table for them
for (n = 0; n < 50000; ++n) {
read_train(train, &id, &delta, (int*)start_grid);
for (i = 0; i < delta; ++i) {
conway_step(start_grid, stop_grid);
vote_step(start_grid, stop_grid, count_case_0[i], count_case_1[i]);
copy_grid(start_grid, stop_grid);
}
}
// vote for statistical table
for (i = 0; i < 5; ++i) {
for (n = 0; n < 2097152; ++n)
vote_case[i][n] = vote_pattern(n, count_case_0[i][n], count_case_1[i][n], i);
}
//------------------------------------------------------------------
// check prediction accuracy
///*
train = fopen ("train.csv", "r");
while (fgetc(train) != '\n') ; // skip the head line
FILE *pred;
pred = fopen ("pred.csv", "w");
fprintf(pred, "id,");
for (n = 1; n < 401; ++n) fprintf(pred, "start.%d,", n);
for (n = 1; n < 400; ++n) fprintf(pred, "diff.%d,", n);
fprintf(pred, "diff.400\n");
double difference_all = 0;
for (n = 0; n < 50000; ++n) {
read_train (train, &id, &delta, (int*)initial_grid);
copy_grid(start_grid, initial_grid);
for (i = 0; i < delta; ++i) {
conway_step(start_grid, stop_grid);
copy_grid(start_grid, stop_grid);
}
for (i = delta-1; i >= 0; --i) {
reverse_step (start_grid, stop_grid, vote_case[i]);
copy_grid(stop_grid, start_grid);
}
write_pred(pred, id, initial_grid, start_grid);
difference_all += difference_grid(initial_grid, start_grid);
}
printf("training set score: %f\n", difference_all/50000);
fclose(pred);
//*/
fclose(train);
//------------------------------------------------------------------
// make submission file
///*
FILE *test;
test = fopen ("test.csv", "r");
while (fgetc(train) != '\n') ; // skip the head line
FILE *submission;
submission = fopen ("submission.csv", "w");
fprintf(submission, "id,");
for (n = 1; n < 400; ++n) fprintf(submission, "start.%d,", n);
fprintf(submission, "start.400\n");
for (n = 0; n < 50000; ++n) {
read_test(test, &id, &delta, stop_grid);
for (i = delta-1; i >= 0; --i) {
reverse_step (start_grid, stop_grid, vote_case[i]);
copy_grid(stop_grid, start_grid);
}
write_submission(submission, id, start_grid);
}
fclose(test);
fclose(submission);
//*/
return 0;
// training set score: 0.12549
// real score: 0.12687
// I also tried set up vote_case table cutoff based on different delta number.
// it may helps (the entire table parameter need a long time to be fixed),
// but a naive setup of the final step (5->6) to 0.5 makes everything goes worse.
}
int main(int argc, char **argv[])
{
string name;
vector<Mat>Images(100), TestImages(50);
vector<Mat> Descriptor(100), TestDescriptor(50), TestPcafeature(50);
vector<vector<KeyPoint>>Keypoints(100), TestKeypoint(50);
Mat histogram = Mat::zeros(100, Cluster, CV_32F);
Mat Testhistogram = Mat::zeros(50, Cluster, CV_32F);
Mat Keyword = Mat::zeros(Cluster, 20, CV_32F);
Mat full_Descriptor, Pcafeature, Pcaduplicate, clusteridx, trainlabels(100, 1, CV_32F);
vector<vector<DMatch>> matches(50);
Mat predicted(Testhistogram.rows, 1, CV_32F);
// Read Training Images.
read_train(Images, name);
//Calculate SIFT features for the Training Images.
calculate_SIFT(Images,Keypoints,Descriptor);
merge_descriptor(full_Descriptor,Descriptor);
//Compute PCA for all the features across all Images.
PCA pca;
perform_PCA(full_Descriptor, Pcafeature, pca);
//Perform K-Means on all the PCA reduced features.
Pcafeature.convertTo(Pcaduplicate, CV_32F);
calculate_Kmeans(Pcaduplicate, clusteridx);
//Calculate the Keywords in the Feature Space.
make_dictionary(clusteridx, Pcaduplicate, Keyword);
//Get the Histogram for each Training Image.
hist(Descriptor, clusteridx, histogram);
//Read Test Image
read_test(TestImages, name);
//Calculate the SIFT feature for all the test Images.
calculate_SIFT(TestImages, TestKeypoint, TestDescriptor);
//Project the SIFT feature of each feature on the lower dimensional PCA plane calculated above.
pca_testProject(TestDescriptor, TestPcafeature, pca);
//Find the Label by searching for keywords closest to current feature.
get_matches(TestPcafeature,Keyword,matches);
//Calculate Histogram for each test Image.
hist_test(TestDescriptor, matches, Testhistogram);
//Perform classification through Knn Classifier.
train_labels(trainlabels);
KNearest knn;
train_classifier(histogram, trainlabels, knn);
test_classify(Testhistogram,predicted,knn);
//Calculate Accuracy for each class.
calculate_accuracy(predicted);
getchar();
return 0;
}
int main(){
struct timeval start;
struct timeval finish;
FILE* f = fopen ("test_output3.txt", "w");
int size;
int sizeOfRegion = 1 << 20;// 1MB
int a = psumeminit(0, sizeOfRegion);
if (a == -1){
fprintf(f, "Initialization failed!\n");
}
void* sample_malloc[20];
void* sample_free[20];
for (int i = 0; i < 20; i++){
void* pointer_array[NUM];
for (int i = 0; i < NUM; i++){
pointer_array[i] = NULL;
}
int duration_malloc = 0;
for (int i = 0; i < NUM; ++i)
{
if (i % 2 == 0){
size = 64;
}
else{
size = 64 * 1024;
}
gettimeofday(&start,NULL);
test* a = (test*)psumalloc(size);
gettimeofday(&finish,NULL);
duration_malloc += (finish.tv_sec*1000000 + finish.tv_usec)- (start.tv_sec*1000000 + start.tv_usec);
write_test(a);
read_test(a, f);
if (a == NULL){
fprintf(f, "No extra space for allocation in memory!\n");
}
else{
pointer_array[i] = a;
fprintf(f, "NO.%d chunk has been allocated. the size is %d bytes\n", i, size);
}
}sample_malloc[i] = duration_malloc;
int duration_free = 0;
for (int i = 0; i < NUM; ++i)
{
gettimeofday(&start,NULL);
int a = psufree(pointer_array[i]);
gettimeofday(&finish,NULL);
if (a == 0){
fprintf(f, "No.%d chunk has been freed. \n", i);
}
else{
fprintf(f, "Can not free No.%d chunk. \n", i);
}
}sample_free[i] = duration_free;
}
qsort((void *)sample_malloc, 20, sizeof(sample_malloc[0]), (int (*)(const void*, const void*))strcmp );
qsort((void *)sample_free, 20, sizeof(sample_free[0]), (int (*)(const void*, const void*))strcmp );
printf("\n25th percentile psumalloc=%d",sample_malloc[4]);
printf("\n75th percentile psumalloc=%d",sample_malloc[14]);
printf("\nAverage psumalloc=%d\n",sample_malloc[9]);
printf("\n25th percentile psufree=%d",sample_free[4]);
printf("\n75th percentile psufree=%d",sample_free[14]);
printf("\nAverage psufree=%d\n",sample_free[9]);
fclose(f);
return 0;
}
void reverse_step (int start_grid[][24], int stop_grid[][24], int vote_case[]) {
int i, j, n, idx;
FLIP_STACK fs = {.size = 0};
for (i = 2; i < 22; ++i) {
for (j = 2; j < 22; ++j) {
idx = get_pattern_idx(stop_grid, i, j);
start_grid[i][j] = vote_case[idx]%2;
if (vote_case[idx] >= 2) push_flip(&fs, i, j);
}
}
FLIP_POINT ijp;
double score_start, score_flip;
for (n = fs.size; n > 0; --n) {
score_start = difference_forward(start_grid, stop_grid);
ijp = pop_flip(&fs);
flip_point(ijp.i, ijp.j, start_grid);
score_flip = difference_forward(start_grid, stop_grid);
if (score_start <= score_flip) flip_point(ijp.i, ijp.j, start_grid);
}
}
////////////////////////////////////////////////////////////////////////
unsigned int count_case_0[5][2097152], count_case_1[5][2097152]; // 2097152 = pow(2, 21)
int vote_case[5][2097152];
//double probability_case[5][2097152];
int main () {
// utility parameters
int n, i;
clean_array((int*)count_case_0, 2097152*5);
clean_array((int*)count_case_1, 2097152*5);
// read the train.csv data
FILE *train;
train = fopen ("train.csv", "r");
while (fgetc(train) != '\n') ; // skip the head line
int id, delta, initial_grid[24][24], start_grid[24][24], stop_grid[24][24];
clean_array((int*)initial_grid, 24*24);
clean_array((int*)start_grid, 24*24);
clean_array((int*)stop_grid, 24*24);
// read all the train set and make statistical table for them
for (n = 0; n < 50000; ++n) {
read_train(train, &id, &delta, (int*)start_grid);
for (i = 0; i < delta; ++i) {
conway_step(start_grid, stop_grid);
vote_step(start_grid, stop_grid, count_case_0[i], count_case_1[i]);
copy_grid(start_grid, stop_grid);
}
}
// vote for statistical table
for (i = 0; i < 5; ++i) {
for (n = 0; n < 2097152; ++n) {
vote_case[i][n] = vote_pattern(n, count_case_0[i][n], count_case_1[i][n], i);
//if (count_case_0[i][n]+count_case_1[i][n] == 0) probability_case[i][n] = 0;
//else probability_case[i][n] = (double)count_case_1[i][n] / (double)(count_case_0[i][n]+count_case_1[i][n]);
}
}
//------------------------------------------------------------------
// check prediction accuracy
/*
train = fopen ("train.csv", "r");
while (fgetc(train) != '\n') ; // skip the head line
FILE *pred;
pred = fopen ("pred.csv", "w");
fprintf(pred, "id,");
for (n = 1; n < 401; ++n) fprintf(pred, "start.%d,", n);
for (n = 1; n < 400; ++n) fprintf(pred, "diff.%d,", n);
fprintf(pred, "diff.400\n");
double difference_all = 0;
for (n = 0; n < 50000; ++n) {
read_train (train, &id, &delta, (int*)initial_grid);
copy_grid(start_grid, initial_grid);
for (i = 0; i < delta; ++i) {
conway_step(start_grid, stop_grid);
copy_grid(start_grid, stop_grid);
}
for (i = delta-1; i >= 0; --i) {
reverse_step (start_grid, stop_grid, vote_case[i]);
copy_grid(stop_grid, start_grid);
}
write_pred(pred, id, initial_grid, start_grid);
difference_all += difference_grids(initial_grid, start_grid);
}
printf("training set score: %f\n", difference_all/50000);
fclose(pred);
*/
fclose(train);
//------------------------------------------------------------------
// make submission file
///*
FILE *test;
test = fopen ("test.csv", "r");
while (fgetc(train) != '\n') ; // skip the head line
FILE *submission;
submission = fopen ("submission.csv", "w");
fprintf(submission, "id,");
for (n = 1; n < 400; ++n) fprintf(submission, "start.%d,", n);
fprintf(submission, "start.400\n");
for (n = 0; n < 50000; ++n) {
read_test(test, &id, &delta, stop_grid);
for (i = delta-1; i >= 0; --i) {
reverse_step (start_grid, stop_grid, vote_case[i]);
copy_grid(stop_grid, start_grid);
}
write_submission(submission, id, start_grid);
}
fclose(test);
fclose(submission);
//*/
return 0;
// training set score: 0.124948 (-0.00054)
// real score: 0.12685 (-0.00002)
// actual improvement is really tiny compare to the training set one.
}
static int worker_run(struct worker *self)
{
char buf[BUFFER_SIZE];
struct sigaction term_sa = {
.sa_handler = SIG_IGN,
.sa_flags = 0,
};
struct queue *q = self->q;
sigaction(SIGTTIN, &term_sa, NULL);
while (1) {
if (!queue_pop(q, buf))
break;
read_test(buf);
}
queue_destroy(q, 1);
tst_flush();
return 0;
}
static void maybe_drop_privs(void)
{
struct passwd *nobody;
if (!drop_privs)
return;
TEST(setgroups(0, NULL));
if (TST_RET < 0 && TST_ERR != EPERM) {
tst_brk(TBROK | TTERRNO,
"Failed to clear suplementary group set");
}
nobody = SAFE_GETPWNAM("nobody");
TEST(setgid(nobody->pw_gid));
if (TST_RET < 0 && TST_ERR != EPERM)
tst_brk(TBROK | TTERRNO, "Failed to use nobody gid");
TEST(setuid(nobody->pw_uid));
if (TST_RET < 0 && TST_ERR != EPERM)
tst_brk(TBROK | TTERRNO, "Failed to use nobody uid");
}
static void spawn_workers(void)
{
int i;
struct worker *wa = workers;
bzero(workers, worker_count * sizeof(*workers));
for (i = 0; i < worker_count; i++) {
wa[i].q = queue_init();
wa[i].pid = SAFE_FORK();
if (!wa[i].pid) {
maybe_drop_privs();
exit(worker_run(wa + i));
}
}
}
main()
{
double t,wps;
int str;
ui count,buflen;
int i,pcount=0;
char strbuf[10];
/* Open our log file */
for(i=1; i<32; ++i)
{
sprintf(strbuf,"cache.%d",i);
if (access(strbuf,0)) break;
}
record=fopen(strbuf,"w");
if (record==NULL) printf("Could not open record file %s. No record kept\n",strbuf);
else printf("\t\tA copy of this run will be kept in %s\n\n",strbuf);
printf("Memory tester v1.0\n");
printf("Author: [email protected], January 1996\n\n");
printf("On this machine, one word = %d bytes\n",sizeof(ui *));
printf("Reported access times are in nS per word.\n\n");
if (record!=NULL)
{
fprintf(record,"On this machine, one word = %d bytes\n",sizeof(ui *));
fprintf(record,"Reported access times are in nS per word.\n\n");
}
/* Start with a block of 256 words, each word is of type (ui *) */
build_buffer(256,1);
count=8;
do
{
count *= 2;
t = read_test(count);
}
while(t < 2);
fflush(stdout);
print_header();
count = (ui)((double)count * LOOPTIME / t);
for(buflen=256; buflen<=MAXBSIZE; buflen*=2)
{
if (buflen<256*1024) sprintf(strbuf,"%uk",buflen/256);
else sprintf(strbuf,"%uM",buflen/(256*1024));
printf("%-5.5s|",strbuf); fflush(stdout);
if (record!=NULL) fprintf(record,"%-5.5s|",strbuf);
for(str=1; str<buflen; str*=2)
{
build_buffer(buflen,str);
while(1)
{
t = read_test(count);
if (t<1.0) count*=3; else break;
}
wps = (double)(count) / t;
wps = 1.0e9 / wps;
if (wps>=1000)
{
printf("1k+ ");
if (record!=NULL) fprintf(record,"1k+ ");
}
else
{
printf("%-3d ", (int)wps);
if (record!=NULL) fprintf(record,"%-3d ", (int)wps);
}
fflush(stdout); if (record!=NULL) fflush(record);
count = (ui)((double)count * LOOPTIME / t);
}
putchar('\n');
if (record!=NULL) putc('\n',record);
}
if (record!=NULL) fclose(record);
}
