int main(int argc, char *argv[])
{
assert(test_init());
for (int speed = 31; speed <= 127; speed += 16)
{
// for (int trial = 0; trial < 4; ++trial)
{
test_speed("start", speed, speed);
test_speed("stop", speed, 0);
}
}
}
int main(void)
{
bool ret = true;
talloc_disable_null_tracking();
talloc_enable_null_tracking();
ret &= test_ref1();
ret &= test_ref2();
ret &= test_ref3();
ret &= test_ref4();
ret &= test_unlink1();
ret &= test_misc();
ret &= test_realloc();
ret &= test_realloc_child();
ret &= test_steal();
ret &= test_move();
ret &= test_unref_reparent();
ret &= test_realloc_fn();
ret &= test_type();
ret &= test_lifeless();
ret &= test_loop();
ret &= test_free_parent_deny_child();
ret &= test_talloc_ptrtype();
if (ret) {
ret &= test_speed();
}
ret &= test_autofree();
if (!ret)
return -1;
return 0;
}
int
main (
int argc,
char *argv[]
) {
int i;
int speed_flag = 0;
int practice_flag = 0;
unsigned long p[64], c[64], k[56];
set_bitlength ();
for (i=1; i<argc; i++) {
if (argv[i][0] != '-')
continue;
if (argv[i][1] == 'S')
speed_flag = 1;
else if (argv[i][1] == 'P')
practice_flag = 1;
}
build_samples (p, c, k, practice_flag);
set_low_keys(k);
if (speed_flag)
test_speed (p, c, k);
else
keysearch (p, c, k);
return 0;
}
/*---------------------------------------------------------------------------*/
usys test_full (usys test_num, usys arg)
{
switch (test_num)
{
case 0:
test_core () ;
return GOOD ;
case 1:
test_speed (arg) ;
return GOOD ;
case 2:
test_timers (arg) ;
return GOOD ;
case 3:
test_msgs (arg) ;
return GOOD ;
case 4:
test_tasks (arg) ;
return GOOD ;
default:
break ;
}
return GOOD ;
} /* End of function test_full() */
int main(int argc, char *argv[]) {
if (argc > 1) {
if (strcmp(argv[1], "0") == 0) {
test_speed();
} else if (strcmp(argv[1], "1") == 0) {
test();
} else if (strcmp(argv[1], "2") == 0) {
test_perft_startpos(4);
test_perft();
} else if (strcmp(argv[1], "3") == 0) {
test_bratko_kopec();
} else if (strcmp(argv[1], "4") == 0) {
test_mate_in_2();
test_eval_depth_1();
test_eval_depth_2();
}
} else {
// Start here
// Waiting for GUI
char *ret;
char input[1001];
while (1) {
ret = fgets(input, 1000, stdin);
if (ret && strstr(input, "uci")) {
break;
}
}
Chess chess;
Util::open_debug_file();
chess.sort_alfarray = true;
chess.start_game();
chess.processCommands(input);
}
}
int main() {
srand(time(0));
test_correctness();
std::cout << "Test succeeded" << std::endl;
test_speed();
std::cout << "Test completed" << std::endl;
}
int parallel_tests()
{
size_t n = 10000000;
std::vector<double> v(n);
int num_failed = 0;
num_failed += test_speed(v);
num_failed += test_correctness(v);
num_failed += test_threadpool();
return num_failed;
}
int parallel_tests()
{
size_t n = 10000000;
std::vector<double> v(n);
int num_failed = 0;
// if we only get one thread on this machine, skip the speed test
if (std::thread::hardware_concurrency() > 1)
num_failed += test_speed(v);
num_failed += test_correctness(v);
num_failed += test_threadpool();
return num_failed;
}
int main(int argc, char *argv[]) {
char c = '\0';
while (-1 != (c = getopt(argc, argv,
"r:"
"p:"
"s:"
"m:"
"v"
))) {
switch (c) {
case 'r':
request_number = atoi(optarg);
break;
case 'p':
pstr_port = optarg;
break;
case 's':
pstr_server = optarg;
break;
case 'm':
buff_size = atoi(optarg);
break;
case 'v':
verbose = 1;
break;
default:
assert(0);
}
}
struct timespec start,
finish;
clock_gettime(CLOCK_REALTIME, &start);
int sockfd = build_connect(pstr_server, pstr_port);
if (sockfd < 0) {
fprintf(stderr, "connect error!\n");
return -1;
}
test_speed(sockfd, buff_size, request_number);
clock_gettime(CLOCK_REALTIME, &finish);
printf("MAIN Cost time: %lf secs\n", (double)(finish.tv_sec-start.tv_sec +
(double)(finish.tv_nsec - start.tv_nsec)/1000000000 ));
return 0;
}
int main(int argc, char *argv[])
{
int numprocs;
int myid;
int i;
int speed_flag = 0;
int practice_flag = 0;
unsigned long p[64], c[64], k[56];
MPI_Init(&argc,&argv);
MPI_Comm_size(MPI_COMM_WORLD,&numprocs);
MPI_Comm_rank(MPI_COMM_WORLD,&myid);
set_bitlength ();
for (i=1; i<argc; i++) {
if (argv[i][0] != '-')
continue;
if (argv[i][1] == 'S')
speed_flag = 1;
else if (argv[i][1] == 'P')
practice_flag = 1;
}
build_samples (p, c, k, practice_flag);
set_low_keys(k);
set_high_keys(k, numprocs, myid);
MPI_Barrier(MPI_COMM_WORLD);
double t=MPI_Wtime();
if (speed_flag)
test_speed (p, c, k);
else
if(keysearch (p, c, k)) MPI_Abort(MPI_COMM_WORLD, 0);
MPI_Barrier(MPI_COMM_WORLD);
double t2=MPI_Wtime();
if(myid==0)printf("time:%f\nspeed:%f\n",t2-t, (double)numprocs*1000000/(t2-t));
MPI_Finalize();
return 0;
}
bool torture_local_talloc(struct torture_context *tctx)
{
bool ret = true;
setlinebuf(stdout);
talloc_disable_null_tracking();
talloc_enable_null_tracking();
ret &= test_ref1();
ret &= test_ref2();
ret &= test_ref3();
ret &= test_ref4();
ret &= test_unlink1();
ret &= test_misc();
ret &= test_realloc();
ret &= test_realloc_child();
ret &= test_steal();
ret &= test_move();
ret &= test_unref_reparent();
ret &= test_realloc_fn();
ret &= test_type();
ret &= test_lifeless();
ret &= test_loop();
ret &= test_free_parent_deny_child();
ret &= test_talloc_ptrtype();
ret &= test_talloc_free_in_destructor();
ret &= test_pool();
if (ret) {
ret &= test_speed();
}
ret &= test_autofree();
return ret;
}
int main(int argc, char* argv[]) {
// a little ugly, but working...
long portno;
long n;
struct sockaddr_in serv_addr;
struct hostent *server;
char buffer[65536];
std::vector<long> brute;
std::vector<long> range;
if (argc < 3) {
exit(0);
fprintf(stderr,"usage %s hostname port\n", argv[0]);
}
portno = atoi(argv[2]);
sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd < 0) {
perror("ERROR opening socket");
exit(EXIT_FAILURE);
}
server = gethostbyname(argv[1]);
if (server == NULL) {
fprintf(stderr,"ERROR, no such host\n");
exit(0);
}
bzero((char *) &serv_addr, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
memmove((char *)&serv_addr.sin_addr.s_addr,
(char *)server->h_addr,
server->h_length);
serv_addr.sin_port = htons(portno);
if (connect(sockfd,(struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0) {
perror("ERROR connecting");
exit(EXIT_FAILURE);
}
//pthread_mutex_init(&the_mutex, NULL);
pthread_attr_t attr;
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
pthread_create(&thread, &attr, kill, (void *) sockfd);
/* send initial Ack message */
double perform;
perform = test_speed();
bzero(buffer,65536);
sprintf(buffer,
"{\"type\": \"ack\", \"data\": {\"perform\": %f}}\r\n",
perform);
write_to_server(sockfd, buffer);
while(true) {
/* read range info from server */
bzero(buffer,65536);
n = recv(sockfd, buffer, 65536, 0);
if (n < 0) {
perror("ERROR reading from socket");
exit(EXIT_FAILURE);
}
range = parse_json_range(buffer);
/* we're at max int, break and exit */
if(range[0] == range[1]) {
std::cout << "Max computation range reached!\n" << range[0];
break;
}
brute.clear();
brute_perfect(range[0], range[1], &brute);
for(int k; k < (int) brute.size(); k++) {
std::cout << brute.at(k) << " ";
}
/* run brute computation and send result */
bzero(buffer, 65536);
build_json_result(range[1], &brute, perform, buffer);
#ifdef DEBUG
std::cout << std::endl << buffer;
#endif
write_to_server(sockfd, buffer);
}
pthread_cancel(thread);
close(sockfd);
return 0;
}
