/*===========================================================================*
* sys_task *
*===========================================================================*/
PUBLIC void sys_task()
{
/* Main entry point of sys_task. Get the message and dispatch on type. */
register int r;
while (TRUE) {
receive(ANY, &m);
switch (m.m_type) { /* which system call */
case SYS_FORK: r = do_fork(&m); break;
case SYS_NEWMAP: r = do_newmap(&m); break;
case SYS_EXEC: r = do_exec(&m); break;
case SYS_XIT: r = do_xit(&m); break;
case SYS_GETSP: r = do_getsp(&m); break;
case SYS_TIMES: r = do_times(&m); break;
case SYS_ABORT: r = do_abort(&m); break;
#if (CHIP == M68000)
case SYS_FRESH: r = do_fresh(&m); break;
#endif
case SYS_SIG: r = do_sig(&m); break;
case SYS_KILL: r = do_kill(&m); break;
case SYS_COPY: r = do_copy(&m); break;
case SYS_GBOOT: r = do_gboot(&m); break;
case SYS_UMAP: r = do_umap(&m); break;
case SYS_MEM: r = do_mem(&m); break;
case SYS_TRACE: r = do_trace(&m); break;
default: r = E_BAD_FCN;
}
m.m_type = r; /* 'r' reports status of call */
send(m.m_source, &m); /* send reply to caller */
}
}
/*===========================================================================*
* sys_task *
*===========================================================================*/
PUBLIC sys_task()
{
/* Main entry point of sys_task. Get the message and dispatch on type. */
register int r;
while (TRUE) {
receive(ANY, &m);
switch (m.m_type) { /* which system call */
case SYS_FORK: r = do_fork(&m); break;
case SYS_NEWMAP: r = do_newmap(&m); break;
case SYS_EXEC: r = do_exec(&m); break;
case SYS_XIT: r = do_xit(&m); break;
case SYS_GETSP: r = do_getsp(&m); break;
case SYS_TIMES: r = do_times(&m); break;
case SYS_ABORT: r = do_abort(&m); break;
case SYS_SIG: r = do_sig(&m); break;
case SYS_COPY: r = do_copy(&m); break;
default: r = E_BAD_FCN;
}
m.m_type = r; /* 'r' reports status of call */
send(m.m_source, &m); /* send reply to caller */
}
}
void
rsource(char *name, struct stat *statp)
{
DIR *dirp;
struct dirent *dp;
char *last, *vect[1], path[MAXPATHLEN];
if (!(dirp = opendir(name))) {
run_err("%s: %s", name, strerror(errno));
return;
}
last = strrchr(name, '/');
if (last == 0)
last = name;
else
last++;
if (pflag) {
if (do_times(remout, verbose_mode, statp) < 0) {
closedir(dirp);
return;
}
}
(void) snprintf(path, sizeof path, "D%04o %d %.1024s\n",
(u_int) (statp->st_mode & FILEMODEMASK), 0, last);
if (verbose_mode)
fprintf(stderr, "Entering directory: %s", path);
(void) atomicio(vwrite, remout, path, strlen(path));
if (response() < 0) {
closedir(dirp);
return;
}
while ((dp = readdir(dirp)) != NULL) {
if (dp->d_ino == 0)
continue;
if (!strcmp(dp->d_name, ".") || !strcmp(dp->d_name, ".."))
continue;
if (strlen(name) + 1 + strlen(dp->d_name) >= sizeof(path) - 1) {
run_err("%s/%s: name too long", name, dp->d_name);
continue;
}
(void) snprintf(path, sizeof path, "%s/%s", name, dp->d_name);
vect[0] = path;
source(1, vect);
}
(void) closedir(dirp);
(void) atomicio(vwrite, remout, "E\n", 2);
(void) response();
}
void
source(int argc, char **argv)
{
struct stat stb;
static BUF buffer;
BUF *bp;
off_t i, statbytes;
size_t amt, nr;
int fd = -1, haderr, indx;
char *last, *name, buf[2048], encname[MAXPATHLEN];
int len;
for (indx = 0; indx < argc; ++indx) {
name = argv[indx];
statbytes = 0;
len = strlen(name);
while (len > 1 && name[len-1] == '/')
name[--len] = '\0';
if ((fd = open(name, O_RDONLY|O_NONBLOCK, 0)) < 0)
goto syserr;
if (strchr(name, '\n') != NULL) {
strnvis(encname, name, sizeof(encname), VIS_NL);
name = encname;
}
if (fstat(fd, &stb) < 0) {
syserr: run_err("%s: %s", name, strerror(errno));
goto next;
}
if (stb.st_size < 0) {
run_err("%s: %s", name, "Negative file size");
goto next;
}
unset_nonblock(fd);
switch (stb.st_mode & S_IFMT) {
case S_IFREG:
break;
case S_IFDIR:
if (iamrecursive) {
rsource(name, &stb);
goto next;
}
/* FALLTHROUGH */
default:
run_err("%s: not a regular file", name);
goto next;
}
if ((last = strrchr(name, '/')) == NULL)
last = name;
else
++last;
curfile = last;
if (pflag) {
if (do_times(remout, verbose_mode, &stb) < 0)
goto next;
}
#define FILEMODEMASK (S_ISUID|S_ISGID|S_IRWXU|S_IRWXG|S_IRWXO)
snprintf(buf, sizeof buf, "C%04o %lld %s\n",
(u_int) (stb.st_mode & FILEMODEMASK),
(long long)stb.st_size, last);
if (verbose_mode) {
fprintf(stderr, "Sending file modes: %s", buf);
}
(void) atomicio(vwrite, remout, buf, strlen(buf));
if (response() < 0)
goto next;
if ((bp = allocbuf(&buffer, fd, COPY_BUFLEN)) == NULL) {
next: if (fd != -1) {
(void) close(fd);
fd = -1;
}
continue;
}
if (showprogress)
start_progress_meter(curfile, stb.st_size, &statbytes);
set_nonblock(remout);
for (haderr = i = 0; i < stb.st_size; i += bp->cnt) {
amt = bp->cnt;
if (i + (off_t)amt > stb.st_size)
amt = stb.st_size - i;
if (!haderr) {
if ((nr = atomicio(read, fd,
bp->buf, amt)) != amt) {
haderr = errno;
memset(bp->buf + nr, 0, amt - nr);
}
}
/* Keep writing after error to retain sync */
if (haderr) {
(void)atomicio(vwrite, remout, bp->buf, amt);
memset(bp->buf, 0, amt);
continue;
}
if (atomicio6(vwrite, remout, bp->buf, amt, scpio,
&statbytes) != amt)
haderr = errno;
}
unset_nonblock(remout);
if (showprogress)
stop_progress_meter();
if (fd != -1) {
if (close(fd) < 0 && !haderr)
haderr = errno;
fd = -1;
}
if (!haderr)
(void) atomicio(vwrite, remout, "", 1);
else
run_err("%s: %s", name, strerror(haderr));
(void) response();
}
}
int main(int argc, char* argv[]) {
int ierr = 0;
int p = 1;
int w = p+7;
int w_name = 13;
try {
// Set up command line options
Teuchos::CommandLineProcessor clp;
clp.setDocString("This program tests the speed of various forward mode AD implementations for a finite-element-like Jacobian fill");
int work_count = 200000;
int num_eqns_begin = 5;
int num_eqns_end = 65;
int num_eqns_delta = 10;
int rt = 0;
clp.setOption("wc", &work_count, "Work count = num_nodes*num_eqns");
clp.setOption("p_begin", &num_eqns_begin, "Intitial number of equations");
clp.setOption("p_end", &num_eqns_end, "Final number of equations");
clp.setOption("p_delta", &num_eqns_delta, "Step in number of equations");
clp.setOption("rt", &rt, "Include ADOL-C retaping test");
// Parse options
Teuchos::CommandLineProcessor::EParseCommandLineReturn
parseReturn= clp.parse(argc, argv);
if(parseReturn != Teuchos::CommandLineProcessor::PARSE_SUCCESSFUL)
return 1;
// Print header
std::cout.setf(std::ios::right);
std::cout << std::setw(w_name) << "Name" << " ";
for (int num_eqns = num_eqns_begin; num_eqns <= num_eqns_end;
num_eqns += num_eqns_delta)
std::cout << std::setw(w) << num_eqns << " ";
std::cout << std::endl;
for (int j=0; j<w_name; j++)
std::cout << '=';
std::cout << " ";
for (int num_eqns = num_eqns_begin; num_eqns <= num_eqns_end;
num_eqns += num_eqns_delta) {
for (int j=0; j<w; j++)
std::cout << '=';
std::cout << " ";
}
std::cout << std::endl;
// Analytic
std::vector<double> times_analytic =
do_times(work_count, num_eqns_begin, num_eqns_end, num_eqns_delta,
analytic_jac_fill);
print_times(times_analytic, times_analytic, "Analytic", p, w, w_name);
#ifdef HAVE_ADIC
// Note there seems to be a bug in ADIC where doing more than one num_eqns
// value results in incorrect timings after the first. Doing one value
// at a time seems to give correct values though.
std::vector<double> times_adic =
do_times(work_count, num_eqns_begin, num_eqns_end, num_eqns_delta,
adic_jac_fill);
print_times(times_adic, times_analytic, "ADIC", p, w, w_name);
#endif
// Original Fad
std::vector<double> times_sfad =
do_times_sfad<Sacado::Fad::SFad>(
work_count, num_eqns_begin, num_eqns_end, num_eqns_delta);
print_times(times_sfad, times_analytic, "SFAD", p, w, w_name);
std::vector<double> times_slfad =
do_times_sfad<Sacado::Fad::SLFad>(
work_count, num_eqns_begin, num_eqns_end, num_eqns_delta);
print_times(times_slfad, times_analytic, "SLFAD", p, w, w_name);
std::vector<double> times_dfad =
do_times_fad<Sacado::Fad::DFad>(
work_count, num_eqns_begin, num_eqns_end, num_eqns_delta);
print_times(times_dfad, times_analytic, "DFAD", p, w, w_name);
// ELR Fad
std::vector<double> times_elr_sfad =
do_times_sfad<Sacado::ELRFad::SFad>(
work_count, num_eqns_begin, num_eqns_end, num_eqns_delta);
print_times(times_elr_sfad, times_analytic, "ELRSFAD", p, w, w_name);
std::vector<double> times_elr_slfad =
do_times_sfad<Sacado::ELRFad::SLFad>(
work_count, num_eqns_begin, num_eqns_end, num_eqns_delta);
print_times(times_elr_slfad, times_analytic, "ELRSLFAD", p, w, w_name);
std::vector<double> times_elr_dfad =
do_times_fad<Sacado::ELRFad::DFad>(
work_count, num_eqns_begin, num_eqns_end, num_eqns_delta);
print_times(times_elr_dfad, times_analytic, "ELRDFAD", p, w, w_name);
// Cache Fad
std::vector<double> times_cache_sfad =
do_times_sfad<Sacado::CacheFad::SFad>(
work_count, num_eqns_begin, num_eqns_end, num_eqns_delta);
print_times(times_cache_sfad, times_analytic, "CacheSFAD", p, w, w_name);
std::vector<double> times_cache_slfad =
do_times_sfad<Sacado::CacheFad::SLFad>(
work_count, num_eqns_begin, num_eqns_end, num_eqns_delta);
print_times(times_cache_slfad, times_analytic, "CacheSLFAD", p, w, w_name);
std::vector<double> times_cache_dfad =
do_times_fad<Sacado::CacheFad::DFad>(
work_count, num_eqns_begin, num_eqns_end, num_eqns_delta);
print_times(times_cache_dfad, times_analytic, "CacheDFAD", p, w, w_name);
// ELR Cache Fad
std::vector<double> times_cache_elr_sfad =
do_times_sfad<Sacado::ELRCacheFad::SFad>(
work_count, num_eqns_begin, num_eqns_end, num_eqns_delta);
print_times(times_cache_elr_sfad, times_analytic, "ELRCacheSFAD", p, w, w_name);
std::vector<double> times_cache_elr_slfad =
do_times_sfad<Sacado::ELRCacheFad::SLFad>(
work_count, num_eqns_begin, num_eqns_end, num_eqns_delta);
print_times(times_cache_elr_slfad, times_analytic, "ELRCacheSLFAD", p, w, w_name);
std::vector<double> times_cache_elr_dfad =
do_times_fad<Sacado::ELRCacheFad::DFad>(
work_count, num_eqns_begin, num_eqns_end, num_eqns_delta);
print_times(times_cache_elr_dfad, times_analytic, "ELRCacheDFAD", p, w, w_name);
}
catch (std::exception& e) {
std::cout << e.what() << std::endl;
ierr = 1;
}
catch (const char *s) {
std::cout << s << std::endl;
ierr = 1;
}
catch (...) {
std::cout << "Caught unknown exception!" << std::endl;
ierr = 1;
}
return ierr;
}
