void Battle::run() {
last_attacking_health = 0;
last_defending_health = 0;
rounds_without_injury = 0;
do {
step();
} while (!check_finished());
}
void newlisp_init_wilddog(char*url)
{
guu_is_wilddog_t gwd;
init_guu_wilddog_t(&gwd);
gwd.wd = init_wilddog(url);
add_observer(&gwd);
loop =1;
while(loop == 1)
{
check_finished(&gwd);
wilddog_trySync();
}
wilddog_close(&gwd);
}
int main(int argc, char **argv)
{
int opt;
char url[1024];
guu_is_wilddog_t gwd;
memset( url, 0, sizeof(url));
while ((opt = getopt(argc, argv, "hl:")) != -1)
{
switch (opt)
{
case 'h':
fprintf(stderr, "Usage: %s -l url\n",
argv[0]);
return 0;
case 'l':
strcpy(url, (const char*)optarg);
break;
default: /* '?' */
fprintf(stderr, "Usage: %s -l url\n",
argv[0]);
return 0;
}
}
if( argc <3 )
{
printf("Usage: %s -l url\n", argv[0]);
return 0;
}
init_guu_wilddog_t(&gwd);
gwd.wd = init_wilddog(url);
add_observer(&gwd);
while(1)
{
check_finished(&gwd);
wilddog_trySync();
}
wilddog_close(&gwd);
return 0;
}
int main(int, char **)
{
fcntl(STDIN_FILENO, F_SETFL, fcntl(STDIN_FILENO, F_GETFL) & ~O_NONBLOCK);
atexit(SDL_Quit);
KInstance in("noatuntyler");
finished = false;
access_mutex = SDL_CreateMutex();
init_renderer1();
printf("%u\n", winID());
fflush(stdout);
init_renderer2();
thread = SDL_CreateThread((int (*)(void *))renderer, NULL);
fd_set set;
struct timeval tv;
while(check_finished() != 1)
{
FD_ZERO(&set);
FD_SET(STDIN_FILENO, &set);
tv.tv_sec = 0;
tv.tv_usec = 250;
if(0 < select(STDIN_FILENO + 1, &set, 0, 0, &tv))
{
SDL_mutexP(access_mutex);
read(STDIN_FILENO, (void *)pcm_data, sizeof(short) * 2 * 512);
SDL_mutexV(access_mutex);
}
usleep(5);
}
/*fprintf(stderr,"exiting main()\n");*/
SDL_WaitThread(thread, NULL);
}
int DataReaderListenerImpl::read_samples (::DDS::DataReader_ptr reader)
{
int num_read = 0;
switch ( num_floats_per_sample_ )
{
case 128:
{
num_read = read < ::Xyz::Pt128Seq,
::Xyz::Pt128DataReader,
::Xyz::Pt128DataReader_ptr,
::Xyz::Pt128DataReaderImpl>
(
reader,
pub_finished_);
}
break;
case 512:
{
num_read = read < ::Xyz::Pt512Seq,
::Xyz::Pt512DataReader,
::Xyz::Pt512DataReader_ptr,
::Xyz::Pt512DataReaderImpl>
(
reader,
pub_finished_);
}
break;
case 2048:
{
num_read = read < ::Xyz::Pt2048Seq,
::Xyz::Pt2048DataReader,
::Xyz::Pt2048DataReader_ptr,
::Xyz::Pt2048DataReaderImpl>
(
reader,
pub_finished_);
}
break;
case 8192:
{
num_read = read < ::Xyz::Pt8192Seq,
::Xyz::Pt8192DataReader,
::Xyz::Pt8192DataReader_ptr,
::Xyz::Pt8192DataReaderImpl>
(
reader,
pub_finished_);
}
break;
default:
ACE_ERROR((LM_ERROR,"ERROR: bad data size %d\n", data_size_));
return 0;
break;
};
stats_.samples_received(num_read);
if (num_read < read_interval_)
{
check_finished();
}
return num_read;
}
int main(int argc, char *argv[]) {
char* remote_ip = DEFAULT_IP;
uint32_t remote_port = DEFAULT_PORT;
struct sockaddr_in addr;
OTRL_INIT;
us = otrl_userstate_create();
if (argc > 1) {
our_account = argv[1];
}
if (argc > 2) {
our_protocol = argv[2];
}
if (argc > 3) {
remote_ip = argv[3];
}
if (argc > 4) {
remote_port = atoi(argv[4]);
}
if (argc > 5) {
logfd = fopen(argv[5], "w");
} else {
logfd = fopen(our_account, "w");
}
pthread_mutex_lock(&log_mutex);
fprintf(logfd, "Connecting to dummy_im: %s:%u\n", remote_ip, remote_port);
fflush(logfd);
pthread_mutex_unlock(&log_mutex);
if ((sockfd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) {
fprintf(stderr, "Cannot create socket\n");
exit(1);
}
memset(&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = inet_addr(remote_ip);
addr.sin_port = htons(remote_port);
if (connect(sockfd, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
fprintf(stderr, "Cannot connect to server\n");
exit(1);
}
pthread_mutex_init(&stdout_mutex, NULL);
pthread_mutex_init(&log_mutex, NULL);
/* pthread launch thread that receives from socket and wrties to stdout */
pthread_t t_socker_reader;
pthread_create(&t_socker_reader, NULL, receive_msgs, (void*) &sockfd);
/* the main thread will receive commands from stdin and write to socket */
while(1) {
unsigned char buf[10];
uint16_t command = 0;
uint32_t id = 0;
uint32_t size = 0;
char* payload = 0;
if (read_stdin(buf, 10) != 10) {
fprintf(stderr, "Error reading from stdin\n");
return;
}
command = ntohs(*((uint16_t*)(buf)));
id = ntohl(*((uint32_t*)(buf+2)));
size = ntohl(*((uint32_t*)(buf+6)));
pthread_mutex_lock(&log_mutex);
fprintf(logfd, "Received command msg: %X id: %u size: %u\n", command, id, size);
fflush(logfd);
pthread_mutex_unlock(&log_mutex);
check_finished(command);
payload = malloc(size);
if (read_stdin(payload, size) != size) {
fprintf(stderr, "Error reading from stdin\n");
return;
}
pthread_mutex_lock(&log_mutex);
fprintf(logfd, "Received payload\n");
fflush(logfd);
pthread_mutex_unlock(&log_mutex);
process_command(command, id, size, &payload);
free(payload);
}
}
int main(int argc, char *argv[])
{
struct sockaddr_in addr;
socklen_t addrlen;
mxbp_packet_t *block_packet;
char *group = NULL;
char *cp;
uint16_t port = DEFAULT_PORT;
int nbytes;
int epollfd;
int sock;
int ctlsock;
int c;
int rv;
int fd;
unsigned int no_sparse = 0;
int timeoutms = DEFAULT_TIMEOUT;
struct epoll_event ev;
struct epoll_event events[10];
progname = strdup(argv[0]);
while ((c = getopt(argc, argv, "g:p:f:s:t:o:nh")) != -1) {
switch (c) {
case 'g':
if (group) {
free(group);
}
group = strdup(optarg);
break;
case 'p':
port = atoi(optarg);
break;
case 't':
timeoutms = atoi(optarg);
break;
case 'f':
from_port = atoi(optarg);
break;
case 's':
if ((cp = strrchr(optarg, ':'))) {
*cp++ = 0;
server_port = atoi(cp);
}
server = strdup(optarg);
break;
case 'o':
if (outputname) {
free(outputname);
}
outputname = strdup(optarg);
break;
case 'n':
no_sparse = 1;
break;
default:
printf("Error: Unrecognized option -%c\n", c);
/* intentional fall through */
case 'h':
usage();
}
}
if (!group) {
group = DEFAULT_GROUP;
}
if (!server) {
server = DEFAULT_SERVER;
}
if (!from_port) {
srand(time(NULL));
from_port = (rand() % 32767) + 32767;
}
mapreq.magic = htobe32(MXBP_MAGIC);
mapreq.op = htobe16(MXBP_MAPREQ);
mapreq.size = 0;
mapreq.blockid = 0;
if ((ctlsock = get_udp_socket(server, from_port)) < 0) {
printf("Error:get_udp_socket(): failed.\n");
exit(EXIT_FAILURE);
}
if ((epollfd = epoll_create(10)) < 0) {
printf("%s:epoll_create(): failed: %s\n", progname,
strerror(errno));
exit(EXIT_FAILURE);
}
ev.events = EPOLLIN;
ev.data.fd = ctlsock;
if (epoll_ctl(epollfd, EPOLL_CTL_ADD, ctlsock, &ev) == -1) {
printf("%s:epoll_ctl(): failed: %s\n", progname,
strerror(errno));
exit(EXIT_FAILURE);
}
for (send_mapreq(ctlsock); !mapdesc.filesize;) {
rv = epoll_wait(epollfd, events, 10, timeoutms);
if (rv < 0) {
printf("%s:epoll_wait(): failed: %s\n", progname,
strerror(errno));
exit(EXIT_FAILURE);
}
if (rv) {
read_mapdesc(ctlsock);
} else {
/* Hit timeout, resend map request. */
send_mapreq(ctlsock);
}
}
close(epollfd);
if (!(blockmap = calloc(1, mapdesc.nblocks))) {
printf("Could not get %d bytes for block map: %s\n",
mapdesc.nblocks, strerror(errno));
exit(EXIT_FAILURE);
}
cp = strrchr(recvfilename, '/');
if (!cp) {
cp = recvfilename;
}
printf("Received description: File %s length %ld blocks %d\n", cp,
mapdesc.filesize, mapdesc.nblocks);
if (outputname) {
cp = outputname;
printf("Overriding output name with '%s'\n", cp);
}
/* There is no resume so we use O_TRUNC
* Note that we could periodically write out the blockmap
* and load that if present to be able to resume, but that's
* not a priority.
*/
if ((fd =
open(cp, O_WRONLY | O_CREAT | O_TRUNC | O_LARGEFILE, 0644)) < 0) {
printf("Could not open %s : %s\n", cp, strerror(errno));
exit(EXIT_FAILURE);
}
if (no_sparse) {
/* Cannot use a sparse file, so now create a big zeroed file. */
char zeros[MXBP_BLOCKSIZE];
int bcount;
memset(zeros, 0, sizeof(zeros));
for (bcount = 0; bcount <= mapdesc.nblocks; ++bcount) {
if (!write(fd, zeros, MXBP_BLOCKSIZE) != MXBP_BLOCKSIZE) {
printf("Failed to write block %d: %s (continuing anyway)\n", bcount, strerror(errno));
}
}
/* Rewind, just in case */
lseek(fd, 0, SEEK_SET);
}
if ((sock = get_multicast_socket(group, port)) < 0) {
printf("Could not get multicast socket.\n");
exit(EXIT_FAILURE);
}
if ((epollfd = epoll_create(10)) < 0) {
printf("%s:epoll_create(): failed: %s\n", progname,
strerror(errno));
exit(EXIT_FAILURE);
}
ev.events = EPOLLIN;
ev.data.fd = sock;
if (epoll_ctl(epollfd, EPOLL_CTL_ADD, sock, &ev) == -1) {
printf("%s:epoll_ctl(): failed: %s\n", progname,
strerror(errno));
exit(EXIT_FAILURE);
}
/* now just enter a read-print loop */
while (1) {
addrlen = sizeof(addr);
memset(msgbuf, 0, MAX_PACKET_SIZE);
rv = epoll_wait(epollfd, events, 10, timeoutms);
if (rv < 0) {
printf("%s:epoll_wait(): failed: %s\n", progname,
strerror(errno));
exit(EXIT_FAILURE);
}
if (rv) {
if ((nbytes =
recvfrom(sock, msgbuf,
sizeof(mxbp_header_t) + MXBP_BLOCKSIZE, 0,
(struct sockaddr *)&addr,
&addrlen)) < 0) {
printf("Failed to receive: %s",
strerror(errno));
exit(EXIT_FAILURE);
}
if (nbytes < sizeof(mxbp_header_t)) {
printf("Got short read, ignoring.\n");
continue;
}
block_packet = (mxbp_packet_t *) msgbuf;
block_packet->header.magic =
be32toh(block_packet->header.magic);
if (block_packet->header.magic != MXBP_MAGIC) {
printf("This is not an MXBP message.\n");
continue;
}
block_packet->header.op =
be16toh(block_packet->header.op);
if (block_packet->header.op != MXBP_BLOCK) {
printf("Unexpected operation %d, ignoring.\n",
block_packet->header.op);
continue;
}
block_packet->header.size =
be16toh(block_packet->header.size);
block_packet->header.blockid =
be32toh(block_packet->header.blockid);
if (block_packet->header.blockid > mapdesc.nblocks) {
printf
("Got Block ID %d past end of file %d, ignoring\n",
block_packet->header.blockid,
mapdesc.nblocks);
continue;
}
if (!blockmap[block_packet->header.blockid]) {
if (lseek64
(fd,
block_packet->header.blockid *
MXBP_BLOCKSIZE, SEEK_SET) && errno) {
printf
("Failed to seek to offset %d: %s\n",
block_packet->header.blockid *
MXBP_BLOCKSIZE, strerror(errno));
exit(EXIT_FAILURE);
}
if (write
(fd, block_packet->data,
block_packet->header.size) !=
block_packet->header.size) {
printf
("Failed to write to offset %d: %s\n",
block_packet->header.blockid *
MXBP_BLOCKSIZE, strerror(errno));
exit(EXIT_FAILURE);
}
blockmap[block_packet->header.blockid] = 1;
if (check_finished()) {
close(ctlsock);
close(sock);
close(epollfd);
close(fd);
printf("All done.\n");
exit(EXIT_SUCCESS);
}
}
} else {
/* Hit the poll timeout, so send a block request. */
send_block_req(ctlsock);
}
}
exit(EXIT_SUCCESS);
}
void mpijob::run_child() {
#ifndef __WINDOWS__
// check that this child hasn't been finished by others
if (check_finished()) {
cout << "child " << conf.get_name()
<< " is already finished, do nothing." << endl;
return ; // already finished, do nothing
}
// start timer
t.start();
string cmd, log, errlog;
log << "out_" << conf.get_name() << ".log";
errlog << "out_" << conf.get_name() << ".errlog";
// prepare command
cmd << "cd " << outdir << " && echo \"job=" << conf.get_name();
if (conf.exists("meta_conf_shortname"))
cmd << " meta_conf_shortname=" << conf.get_string("meta_conf_shortname");
// not finished, check if it has been started in the past
if (check_started()) {
cout << "child " << conf.get_name()
<< " is already started but not finished, resuming." << endl;
figure_resume_out();
if (conf.exists("retrain_iteration") && conf.exists("retrain_weights")
&& conf.exists("retrain")) {
// add retrain params at the end of job's conf
ofstream of(confname.c_str(), ios_base::app);
if (!of)
eblerror("failed to open conf for appending retrain params: "
<< confname);
of << endl
<< " retrain_iteration=" << conf.get_string("retrain_iteration")
<< endl << " retrain_weights=" << conf.get_string("retrain_weights")
<< endl << " retrain=" << conf.get_string("retrain") << endl;
of.close();
}
}
// set classe filename if defined
if (rconf.exists("train") || rconf.exists("train_classes")) {
string classesname = conf.get_output_dir();
if (rconf.exists("train"))
classesname << "/" << rconf.get_string("train");
else if (rconf.exists("train_classes"))
classesname << "/" << rconf.get_string("train_classes");
classesname << CLASSES_NAME << MATRIX_EXTENSION;
cmd << " classes=" << classesname;
}
// set rest of command
cmd << " config=" << confname << "\" >> "
<< log << " && ((" << exe << " " << confname
<< " 3>&1 1>&2 2>&3 | tee /dev/tty | tee -a " << errlog
<< ") 3>&1 1>&2 2>&3) >> " << log << " 2>&1 && exit 0";
// execute child
cout << endl << "(mpi) Executing job " << basename(confname.c_str())
<< " with cmd:" << endl << cmd << endl;
int ret = std::system(cmd.c_str());
if (ret != 0) {
cerr << "child command error: " << ret << endl;
cerr << "WIFSIGNALED(" << ret << "): " << WIFSIGNALED(ret) << endl;
cerr << "WTERMSIG(" << ret << "): " << WTERMSIG(ret) << endl;
}
#else
eblerror("not implemented");
#endif
}
