std::string vshow(const DexField* p) {
if (!p) return "";
std::ostringstream ss;
ss << accessibility(p->get_access()) << humanize(show(p->get_type())) << " "
<< humanize(show(p->get_class())) << "." << show(p->get_name());
if (p->get_anno_set()) {
ss << "\n annotations:" << show(p->get_anno_set());
}
return ss.str();
}
std::string vshow(const DexMethod* p, bool include_annotations /*=true*/) {
if (!p) return "";
std::ostringstream ss;
ss << vshow(p->get_access())
<< vshow(p->get_proto()->get_rtype()) << " "
<< humanize(show(p->get_class())) << "." << show(p->get_name())
<< vshow(p->get_proto(), false);
if (include_annotations) {
if (p->get_anno_set()) {
ss << "\n annotations:" << show(p->get_anno_set());
}
bool first = true;
if (p->get_param_anno() != nullptr) {
for (auto const pair : *p->get_param_anno()) {
if (first) {
ss << "\n param annotations:"
<< "\n";
first = false;
}
ss << " " << pair.first << ": " << show(pair.second) << "\n";
}
}
}
return ss.str();
}
static void progress(const char *acc, uint64_t sz,
uint64_t srcSz, uint64_t hSrc, char sfSrc, KTime_t date)
{
if (sz > 0) {
if (srcSz > 0) {
uint64_t p = 100 * sz / srcSz;
char sf = 'B';
uint64_t fr = 0;
uint64_t h = humanize(sz, &sf, &fr);
if (p > 0) {
if (sfSrc != 'B' && sf != 'B') {
if (fr == 0) {
if (date == 0) {
OUTMSG(("%s %,ld/%,ld %ld%c/%,ld%c %ld%% \r",
acc, sz, srcSz, h,sf,hSrc,sfSrc,p));
}
else {
OUTMSG(("%s %,ld/%,ld %ld%c/%,ld%c %ld%% %ld \r",
acc, sz, srcSz, h,sf,hSrc,sfSrc,p,
KTimeStamp() - date));
}
}
else {
OUTMSG(("%s %,ld/%,ld %ld.%03ld%c/%,ld%c %ld%% \r",
acc, sz, srcSz,h,fr,sf,hSrc,sfSrc,p));
}
}
else {
OUTMSG(("%s %,ld/%,ld %ld%% \r",
acc, sz, srcSz, p));
}
}
else {
if (sfSrc != 'B' && sf != 'B') {
if (fr == 0) {
OUTMSG((
"%s %,ld/%,ld %ld%c/%ld%c \r",
acc, sz,srcSz,h, sf,hSrc,sfSrc));
}
else {
OUTMSG((
"%s %,ld/%,ld %ld.%03ld%c/%ld%c \r",
acc, sz,srcSz,h, fr,sf,hSrc,sfSrc));
}
}
else {
OUTMSG(("%s %,ld/%,ld \r", acc, sz, srcSz));
}
}
}
else {
OUTMSG(("%s %,ld \r", acc, sz));
}
}
else {
OUTMSG((" \r%s\r", acc));
}
}
std::string vshow(const DexProto* p, bool include_ret_type = true) {
if (!p) return "";
std::ostringstream ss;
ss << "(" << vshow(p->get_args()) << ")";
if (include_ret_type) {
ss << humanize(show(p->get_rtype()));
}
return ss.str();
}
std::string vshow(const DexClass* p) {
if (!p) return "";
std::ostringstream ss;
ss << accessibility(p->get_access()) << humanize(show(p->get_type()))
<< " extends " << humanize(show(p->get_super_class()));
if (p->get_interfaces()) {
ss << " implements ";
bool first = true;
for (auto const type : p->get_interfaces()->get_type_list()) {
if (first)
first = false;
else
ss << ", ";
ss << humanize(show(type));
}
}
if (p->get_anno_set()) {
ss << "\n annotations:" << show(p->get_anno_set());
}
return ss.str();
}
std::string vshow(const DexTypeList* p) {
if (!p) return "";
std::ostringstream ss;
bool first = true;
for (auto const& type : p->get_type_list()) {
if (!first) {
ss << ", ";
} else {
first = false;
}
ss << humanize(show(type));
}
return ss.str();
}
/*
* Display used, available and total correctly formatted
* @n: number to print
* @perct: percentage (useful for finding which color to use)
* @req_width: required width (used for terminal display, otherwise can be 0)
*/
static void
text_disp_uat(double n, double perct, int req_width)
{
int i;
i = 0;
if (unitflag == 'h')
i = humanize(&n);
change_color(perct);
(void)printf("%*.1f", req_width - 1, n); /* -1 for the unit symbol */
reset_color();
print_unit(i, 1);
}
int main(int argc, char **argv)
{
if(argc != 3)
{
printf("usage: %s block_size tests_count\n", argv[0]);
return -1;
}
size_t bs = atoll(argv[1]);
switch(argv[1][strlen(argv[1]) - 1])
{
case 'g':
case 'G':
bs *= 1000000000;
break;
case 'm':
case 'M':
bs *= 1000000;
break;
case 'k':
case 'K':
bs *= 1000;
break;
}
unsigned a = atoi(argv[2]), i;
int failed = 0;
for(i = 0; i < a; ++i)
{
uint8_t *ptr = malloc(bs);
*ptr = 'A';
//memset(ptr, 'A', bs);
int r = 0;//memcmp(ptr, main, (uint64_t)dum - (uint64_t)main);
//if(*ptr != 'A') r = 1;
//if(r) ++failed;
printf("[%6d] : 0x%016lX (%s)\n", i, ptr, r?"failed":"passed");
int s = 0;
}
printf("Memory test %s with %d test(s) [%u %s]\n", failed?"failed":"passed",
a, humanize(a * bs), size(a * bs));
//*(char*)(-1) = 5; // break kernel
}
int main (int argc, char **argv)
{
char ch, pow = 0, fac = 0;
double number = 0;
/* only switches are use to force factorization */
while ((ch = getopt(argc, argv, "hbkmgt")) != -1) {
switch (ch) {
case 'h': usage(argv[0]); exit(0); break;
case 't': fac = 'T'; break;
case 'g': fac = 'G'; break;
case 'm': fac = 'M'; break;
case 'k': fac = 'K'; break;
case 'b': fac = 'B'; break;
}
}
switch (argv[argc - 1][strnlen(argv[argc - 1],32) - 1]) {
case 'T': pow++;
case 'G': pow++;
case 'M': pow++;
case 'K': pow++;
case 'B': argv[argc - 1][strnlen(argv[argc - 1],32) - 1] = 0;
}
/* get the number and convert it to bytes. If there is none, strtold will return 0 */
number = strtold(argv[argc - 1], NULL);
number *= power(1024, pow);
if (number <= 0) {
errx(EXIT_FAILURE, "I ain't gonna do that. Deal with it.");
}
/* use explicit factorization. otherwise, guess the best one */
fac = fac > 0 ? fac : factorize(number);
/* actually print the result, isn't that what we're here for after all ? */
printf("%.*f%c\n", getscale(), humanize(number, fac), fac == 'B' ? 0 : fac);
return 0;
}
/*
* Display available and total correctly formatted
* @n: number to print
* @perct: ignored here
* @req_width: ignored here
*/
static void
html_disp_uat(double n, double perct, int req_width)
{
int i;
(void)perct;
(void)req_width;
(void)printf("\t <td style = \"text-align: right;\">");
if (unitflag == 'h') {
i = humanize(&n);
(void)printf(i == 0 ? "%.f" : "%.1f", n);
print_unit(i, 1);
} else {
if (unitflag == 'b' || unitflag == 'k')
(void)printf("%.f", n);
else
(void)printf("%.1f", n);
}
(void)puts("</td>");
}
rc_t run_ascp(const char *path, const char *key,
const char *src, const char *dest, const AscpOptions *opt)
{
const char *host = NULL;
const char *user = NULL;
const char *maxRate = NULL;
bool cache_key = false;
uint64_t heartbeat = 0;
const char *acc = NULL;
uint64_t srcSz = 0;
uint64_t id = 0;
TProgress *callback = NULL;
TQuitting *quitting = NULL;
rc_t rc = 0;
pid_t nPid = 0;
int pipeto[2]; /* pipe to feed the exec'ed program input */
int pipefrom[2]; /* pipe to get the exec'ed program output */
#define ARGV_SZ 64
char *argv[ARGV_SZ];
char extraOptions[4096] = "";
int i = 0;
int ret = 0;
i = 0;
if (opt != NULL) {
acc = opt->name;
cache_key = opt->cache_key;
callback = opt->callback;
heartbeat = opt->heartbeat;
host = opt->host;
id = opt->id;
quitting = opt->quitting;
srcSz = opt->src_size;
user = opt->user;
if (opt->ascp_options != NULL) {
size_t s = string_size(opt->ascp_options);
if (s >= sizeof extraOptions) {
LOGERR(klogErr,
RC(rcExe, rcProcess, rcCreating, rcBuffer, rcInsufficient),
"extra ascp options are ignored");
maxRate = opt->target_rate;
}
else {
string_copy
(extraOptions, sizeof extraOptions, opt->ascp_options, s);
}
}
else {
maxRate = opt->target_rate;
}
}
if (acc == NULL) {
acc = dest;
}
if (heartbeat > 0) {
heartbeat /= 1000;
if (heartbeat == 0) {
heartbeat = 1;
}
}
if (pipe(pipeto) != 0) {
perror("pipe() to");
rc = RC(rcExe, rcFileDesc, rcCreating, rcFileDesc, rcFailed);
LOGERR(klogErr, rc, "while pipe");
return rc;
}
if (pipe(pipefrom) != 0) {
perror("pipe() from");
rc = RC(rcExe, rcFileDesc, rcCreating, rcFileDesc, rcFailed);
LOGERR(klogErr, rc, "while pipe");
return rc;
}
argv[i++] = (char*)path;
argv[i++] = "-i";
argv[i++] = (char*)key;
argv[i++] = "-pQTk1";
if (maxRate != NULL && maxRate[0] != '\0') {
argv[i++] = "-l";
argv[i++] = (char*)maxRate;
}
if (user != NULL) {
argv[i++] = "--user";
argv[i++] = (char*)user;
}
if (host != NULL) {
argv[i++] = "--host";
argv[i++] = (char*)user;
}
if (extraOptions[0] != '\0') {
bool done = false;
char *c = extraOptions;
while (!done) {
while (true) {
if (*c == '\0') {
break;
}
else if (isspace(*c)) {
++c;
}
else {
break;
}
}
if (*c == '\0') {
break;
}
else {
argv[i++] = c;
}
while (true) {
if (*c == '\0') {
done = true;
break;
}
else if (isspace(*c)) {
*(c++) = '\0';
break;
}
++c;
}
if (i > ARGV_SZ - 4) {
LOGERR(klogErr,
RC(rcExe, rcProcess, rcCreating, rcBuffer, rcInsufficient),
"too mary extra ascp options - some of them are ignored");
break;
}
}
}
argv[i++] = (char*)src;
argv[i++] = (char*)dest;
argv[i++] = NULL;
logevp(path, argv);
if (quitting) {
rc = quitting();
}
if (rc != 0) {
return rc;
}
nPid = fork();
if (nPid < 0 ) {
perror("fork() 1");
rc = RC(rcExe, rcProcess, rcCreating, rcProcess, rcFailed);
LOGERR(klogErr, rc, "after fork");
return rc;
}
else if (nPid == 0) {
/* dup pipe read/write to stdin/stdout */
dup2(pipeto [0], STDIN_FILENO);
dup2(pipefrom[1], STDOUT_FILENO);
dup2(pipefrom[1], STDERR_FILENO);
close(pipeto[1]);
ret = execvp(path, argv);
STSMSG(STS_DBG, ("CHILD: Done %s %s %s = %d", path, src, dest, ret));
exit(EXIT_FAILURE);
}
else {
bool progressing = false;
bool writeFailed = false;
EAscpState state = eStart;
const char y[] = "y\n";
const char n[] = "n\n";
int status = 0;
int w = 0;
int fd = pipefrom[0];
const char *answer = n;
String line;
StringInit(&line, NULL, 0, 0);
if (cache_key) {
answer = y;
}
{
int flags = fcntl(fd, F_GETFL, 0);
fcntl(fd, F_SETFL, flags | O_NONBLOCK);
}
close(pipeto[0]);
close(pipefrom[1]);
assert(sizeof y == sizeof n);
{
int hang = 0;
uint64_t prev = 0;
KTime_t tPrev = 0;
char sfSrc = 'B';
uint64_t hSrc = humanize(srcSz, &sfSrc, NULL);
int sig = 0;
uint64_t i = 0;
KDirectory *dir = NULL;
rc_t rc = KDirectoryNativeDir(&dir);
DISP_RC(rc, "KDirectoryNativeDir");
if (rc != 0) {
return rc;
}
while (w == 0) {
bool quit = false;
w = waitpid(nPid, &status, WNOHANG);
if (w == 0) {
bool got = false;
rc_t rc = 0;
if (quitting) {
rc = quitting();
}
if (rc != 0 || quit) {
if (sig == 0) {
sig = SIGINT;
}
else if (sig >= SIGKILL) {
break;
}
else {
++sig;
}
if (progressing) {
OUTMSG(("\n"));
}
PLOGMSG(klogInfo, (klogInfo, "^C pressed: "
"Senging $(sgn) to ascp", "sgn=%s", sig));
kill(nPid, sig);
}
while (true) {
char buf[4096];
int s = read(fd, buf, sizeof buf);
if (s == 0) {
break;
}
else if (s < 0) {
if (errno != EAGAIN) {
if (progressing) {
OUTMSG(("\n"));
}
perror("read(child)");
}
break;
}
ascpParse(buf, s, dest, &state, &line);
switch (state) {
case eKeyEnd:
write(pipeto[1], answer, sizeof y - 1);
break;
case eWriteFailed:
writeFailed = true;
break;
default:
break;
}
got = true;
}
if (!got) {
sleep(1);
++i;
if ((heartbeat > 0 && i >= heartbeat) || (i > 99)) {
uint64_t size = 0;
rc_t rc = KDirectoryFileSize(dir, &size, "%s", dest);
if (rc != 0) {
size = 0;
}
else {
if (size != prev) {
prev = size;
tPrev = 0;
hang = 0;
}
else {
KTime_t date = 0;
rc_t rc = KDirectoryDate(dir, &date, "%s", dest);
if (rc == 0) {
tPrev = date;
if ((KTimeStamp() - date) > 60 * 99) {
/* no file update during 99' */
if (hang == 0) {
write(pipeto[1],
answer, sizeof y - 1);
++hang;
}
else if (hang < 9) {
++hang;
sig = 0;
}
else {
if (sig == 0) {
sig = SIGINT;
}
else {
++sig;
}
if (progressing) {
OUTMSG(("\n"));
}
if (sig > SIGKILL) {
rc = RC(rcExe,
rcProcess, rcExecuting,
rcProcess,rcDetached);
return rc;
}
PLOGMSG(klogInfo, (klogInfo,
"Senging $(sgn) to ascp",
"sgn=%s", sig));
kill(nPid, sig);
}
}
}
}
}
if (heartbeat > 0) {
if (callback) {
quit = !callback(id,
eAscpStateRunning, size, 0);
}
else {
progress(acc, size, srcSz, hSrc, sfSrc,
tPrev);
}
progressing = true;
}
i = 0;
}
}
}
}
RELEASE(KDirectory, dir);
}
if (progressing) {
OUTMSG(("\n"));
}
while (1) {
char buf[4096];
int s = read(fd, buf, sizeof buf);
if (s == 0) {
break;
}
else if (s < 0) {
if (errno != EAGAIN) {
perror("read(child)");
break;
}
continue;
}
ascpParse(buf, s, dest, &state, &line);
if (state == eWriteFailed) {
writeFailed = true;
}
}
STSMSG( STS_DBG, ("ascp exited with pid=%d status=%d", w, status));
if (WIFEXITED(status)) {
STSMSG(STS_DBG, ("ascp exited with exit status %d",
WEXITSTATUS(status)));
}
else {
STSMSG(STS_DBG, ("ascp has not terminated correctly"));
}
if (w == -1) {
perror("waitpid");
rc = RC(rcExe, rcProcess, rcWaiting, rcProcess, rcFailed);
LOGERR(klogErr, rc, "after waitpid");
exit(EXIT_FAILURE);
}
if (WIFEXITED(status)) {
if (WEXITSTATUS(status) == 0) {
STSMSG(STS_DBG, ("ascp succeed"));
if (callback) {
callback(id, eAscpStateExitSuccess, 0, 0);
}
} else if (writeFailed) {
rc = RC(rcExe, rcProcess, rcExecuting, rcMemory, rcExhausted);
if (callback) {
callback(id, eAscpStateExitWriteFailure, 0, 0);
}
}
else {
if (rc == 0) {
rc = RC(rcExe, rcProcess, rcWaiting, rcProcess, rcFailed);
}
PLOGERR(klogErr, (klogErr, rc,
"ascp failed with $(ret)", "ret=%d", WEXITSTATUS(status)));
if (callback) {
callback(id, eAscpStateExitFailure, 0, 0);
}
}
} else if (WIFSIGNALED(status)) {
if (rc == 0) {
if (quitting) {
rc = quitting();
if (rc == 0) {
rc = RC(rcExe,
rcProcess, rcWaiting, rcProcess, rcFailed);
}
}
}
if (rc != SILENT_RC(rcExe, rcProcess, rcExecuting,
rcProcess, rcCanceled))
{
PLOGERR(klogErr, (klogErr, rc, "ascp killed by signal $(sig)",
"sig=%d", WTERMSIG(status)));
if (callback) {
callback(id, eAscpStateExitFailure, 0, 0);
}
}
}
}
return rc;
}
int tool_main(int argc, char** argv) {
SetupCrashHandler();
SkAutoGraphics ag;
SkCommandLineFlags::Parse(argc, argv);
const double overhead = estimate_timer_overhead();
if (FLAGS_verbose) {
// No header.
} else if (FLAGS_quiet) {
SkDebugf("min\tbench\tconfig\n");
} else {
SkDebugf("loops\tmin\tmean\tmax\tstddev\tbench\tconfig\n");
}
for (const BenchRegistry* r = BenchRegistry::Head(); r != NULL; r = r->next()) {
SkAutoTDelete<Benchmark> bench(r->factory()(NULL));
if (SkCommandLineFlags::ShouldSkip(FLAGS_match, bench->getName())) {
continue;
}
SkTDArray<SkSurface*> surfaces;
SkTDArray<const char*> configs;
create_surfaces(bench.get(), &surfaces, &configs);
bench->preDraw();
for (int j = 0; j < surfaces.count(); j++) {
SkCanvas* canvas = surfaces[j] ? surfaces[j]->getCanvas() : NULL;
const char* config = configs[j];
bench->draw(1, canvas); // Just paranoid warmup.
safe_flush(canvas);
const int loops = guess_loops(overhead, bench.get(), canvas);
SkAutoTMalloc<double> samples(FLAGS_samples);
WallTimer timer;
for (int i = 0; i < FLAGS_samples; i++) {
timer.start();
bench->draw(loops, canvas);
safe_flush(canvas);
timer.end();
samples[i] = timer.fWall / loops;
}
Stats stats(samples.get(), FLAGS_samples);
if (FLAGS_verbose) {
for (int i = 0; i < FLAGS_samples; i++) {
SkDebugf("%s ", humanize(samples[i]).c_str());
}
SkDebugf("%s\n", bench->getName());
} else if (FLAGS_quiet) {
if (configs.count() == 1) {
config = ""; // Only print the config if we run the same bench on more than one.
}
SkDebugf("%s\t%s\t%s\n", humanize(stats.min).c_str(), bench->getName(), config);
} else {
const double stddev_percent = 100 * sqrt(stats.var) / stats.mean;
SkDebugf("%d\t%s\t%s\t%s\t%.0f%%\t%s\t%s\n"
, loops
, humanize(stats.min).c_str()
, humanize(stats.mean).c_str()
, humanize(stats.max).c_str()
, stddev_percent
, bench->getName()
, config
);
}
}
surfaces.deleteAll();
}
return 0;
}
std::string vshow(const DexType* t) {
return humanize(show(t));
}
