void
randomize(struct amino_acid *amino_acid, int amino_acid_size,
const char *title, int n, random_t *rand) {
struct amino_acid *lookup[LOOKUP_SIZE];
char line_buffer[LINE_LEN + 1];
int i, j;
line_buffer[LINE_LEN] = '\n';
fill_lookup(lookup, amino_acid, amino_acid_size);
fputs_unlocked(title, stdout);
for (i = 0, j = 0; i < n; i++, j++) {
if (j == LINE_LEN) {
fwrite_unlocked(line_buffer, LINE_LEN + 1, 1, stdout);
j = 0;
}
float r = random_next_lookup(rand);
struct amino_acid *u = lookup[(short)r];
while (unlikely(u->cprob_lookup < r)) {
++u;
}
line_buffer[j] = u->sym;
}
line_buffer[j] = '\n';
fwrite_unlocked(line_buffer, j + 1, 1, stdout);
}
static int snappy_java_compress(FILE *infp, FILE *outfp, size_t block_size)
{
snappy_java_header_t header;
work_buffer_t wb;
size_t uncompressed_length;
int err = 1;
wb.c = NULL;
wb.uc = NULL;
if (block_size == 0) {
block_size = DEFAULT_BLOCK_SIZE;
}
/* write the file header */
memcpy(header.magic, SNAPPY_JAVA_MAGIC, SNAPPY_JAVA_MAGIC_LEN);
header.version = htonl(SNAPPY_JAVA_FILE_VERSION);
header.compatible_version = htonl(SNAPPY_JAVA_FILE_VERSION);
if (fwrite_unlocked(&header, sizeof(header), 1, outfp) != 1) {
print_error("Failed to write a file: %s\n", strerror(errno));
goto cleanup;
}
/* write file body */
work_buffer_init(&wb, block_size);
while ((uncompressed_length = fread_unlocked(wb.uc, 1, wb.uclen, infp)) > 0) {
size_t compressed_length = wb.clen;
trace("read %lu bytes.\n", (unsigned long)uncompressed_length);
/* compress the block. */
snappy_compress(wb.uc, uncompressed_length, wb.c, &compressed_length);
trace("compressed_legnth is %lu.\n", (unsigned long)compressed_length);
/* write the compressed length. */
putc_unlocked((compressed_length >> 24), outfp);
putc_unlocked((compressed_length >> 16), outfp);
putc_unlocked((compressed_length >> 8), outfp);
putc_unlocked((compressed_length >> 0), outfp);
trace("write 4 bytes for compressed data length.\n");
/* write the compressed data. */
if (fwrite_unlocked(wb.c, compressed_length, 1, outfp) != 1) {
print_error("Failed to write a file: %s\n", strerror(errno));
goto cleanup;
}
trace("write %ld bytes for compressed data.\n", (long)compressed_length);
}
if (!feof_unlocked(infp)) {
/* fread_unlocked() failed. */
print_error("Failed to read a file: %s\n", strerror(errno));
goto cleanup;
}
err = 0;
cleanup:
work_buffer_free(&wb);
return err;
}
int
jvmti_write_code(void *agent, char const *sym,
uint64_t vma, void const *code, unsigned int const size)
{
static int code_generation = 1;
struct jr_code_load rec;
size_t sym_len;
FILE *fp = agent;
int ret = -1;
/* don't care about 0 length function, no samples */
if (size == 0)
return 0;
if (!fp) {
warnx("jvmti: invalid fd in write_native_code");
return -1;
}
sym_len = strlen(sym) + 1;
rec.p.id = JIT_CODE_LOAD;
rec.p.total_size = sizeof(rec) + sym_len;
rec.p.timestamp = perf_get_timestamp();
rec.code_size = size;
rec.vma = vma;
rec.code_addr = vma;
rec.pid = getpid();
rec.tid = gettid();
if (code)
rec.p.total_size += size;
/*
* If JVM is multi-threaded, nultiple concurrent calls to agent
* may be possible, so protect file writes
*/
flockfile(fp);
/*
* get code index inside lock to avoid race condition
*/
rec.code_index = code_generation++;
ret = fwrite_unlocked(&rec, sizeof(rec), 1, fp);
fwrite_unlocked(sym, sym_len, 1, fp);
if (code)
fwrite_unlocked(code, size, 1, fp);
funlockfile(fp);
ret = 0;
return ret;
}
int op_write_native_code(op_agent_t hdl, char const * symbol_name,
uint64_t vma, void const * code, unsigned int const size)
{
struct jr_code_load rec;
struct timeval tv;
size_t sz_symb_name;
char pad_bytes[7] = { 0, 0, 0, 0, 0, 0, 0 };
size_t padding_count;
FILE * dumpfile = (FILE *) hdl;
if (!dumpfile) {
errno = EINVAL;
fprintf(stderr, "Invalid hdl argument\n");
return -1;
}
sz_symb_name = strlen(symbol_name) + 1;
rec.id = JIT_CODE_LOAD;
rec.code_size = size;
rec.vma = vma;
rec.code_addr = (u64) (uintptr_t) code;
rec.total_size = code ? sizeof(rec) + sz_symb_name + size :
sizeof(rec) + sz_symb_name;
/* calculate amount of padding '\0' */
padding_count = PADDING_8ALIGNED(rec.total_size);
rec.total_size += padding_count;
if (gettimeofday(&tv, NULL)) {
fprintf(stderr, "gettimeofday failed\n");
return -1;
}
rec.timestamp = tv.tv_sec;
/* locking makes sure that we continuously write this record, if
* we are called within a multi-threaded context */
flockfile(dumpfile);
/* Write record, symbol name, code (optionally), and (if necessary)
* additonal padding \0 bytes.
*/
if (fwrite_unlocked(&rec, sizeof(rec), 1, dumpfile) &&
fwrite_unlocked(symbol_name, sz_symb_name, 1, dumpfile)) {
if (code)
fwrite_unlocked(code, size, 1, dumpfile);
if (padding_count)
fwrite_unlocked(pad_bytes, padding_count, 1, dumpfile);
/* Always flush to ensure conversion code to elf will see
* data as soon as possible */
fflush_unlocked(dumpfile);
funlockfile(dumpfile);
return 0;
}
fflush_unlocked(dumpfile);
funlockfile(dumpfile);
return -1;
}
int op_write_native_code(op_agent_t hdl, char const * symbol_name,
uint64_t vma, void const * code, unsigned int const size)
{
struct jr_code_load rec;
struct timeval tv;
size_t sz_symb_name;
char pad_bytes[7] = { 0, 0, 0, 0, 0, 0, 0 };
size_t padding_count;
FILE * dumpfile = (FILE *) hdl;
if (!dumpfile) {
errno = EINVAL;
fprintf(stderr, "Invalid hdl argument\n");
return -1;
}
sz_symb_name = strlen(symbol_name) + 1;
rec.id = JIT_CODE_LOAD;
rec.code_size = size;
rec.vma = vma;
rec.code_addr = (u64) (uintptr_t) code;
rec.total_size = code ? sizeof(rec) + sz_symb_name + size :
sizeof(rec) + sz_symb_name;
padding_count = PADDING_8ALIGNED(rec.total_size);
rec.total_size += padding_count;
if (gettimeofday(&tv, NULL)) {
fprintf(stderr, "gettimeofday failed\n");
return -1;
}
rec.timestamp = tv.tv_sec;
flockfile(dumpfile);
if (fwrite_unlocked(&rec, sizeof(rec), 1, dumpfile) &&
fwrite_unlocked(symbol_name, sz_symb_name, 1, dumpfile)) {
if (code)
fwrite_unlocked(code, size, 1, dumpfile);
if (padding_count)
fwrite_unlocked(pad_bytes, padding_count, 1, dumpfile);
fflush_unlocked(dumpfile);
funlockfile(dumpfile);
return 0;
}
fflush_unlocked(dumpfile);
funlockfile(dumpfile);
return -1;
}
static int write_block(FILE *outfp, const char *buffer, size_t length, int compressed, unsigned int crc32c)
{
/* write compressed flag */
putc_unlocked(compressed ? COMPRESSED_FLAG : UNCOMPRESSED_FLAG, outfp);
trace("write 1 byte for compressed flag.\n");
/* write data length. */
putc_unlocked((length >> 8), outfp);
putc_unlocked((length >> 0), outfp);
trace("write 2 bytes for data length.\n");
/* write crc32c */
putc_unlocked((crc32c >> 24), outfp);
putc_unlocked((crc32c >> 16), outfp);
putc_unlocked((crc32c >> 8), outfp);
putc_unlocked((crc32c >> 0), outfp);
trace("write 4 bytes for crc32c.\n");
if (fwrite_unlocked(buffer, length, 1, outfp) != 1) {
print_error("Failed to write a file: %s\n", strerror(errno));
return -1;
}
trace("write %ld bytes for data.\n", (long)length);
return 0;
}
static void write_env_var(FILE *f, const char *v) {
const char *p;
p = strchr(v, '=');
if (!p) {
/* Fallback */
fputs_unlocked(v, f);
fputc_unlocked('\n', f);
return;
}
p++;
fwrite_unlocked(v, 1, p-v, f);
if (string_has_cc(p, NULL) || chars_intersect(p, WHITESPACE SHELL_NEED_QUOTES)) {
fputc_unlocked('\"', f);
for (; *p; p++) {
if (strchr(SHELL_NEED_ESCAPE, *p))
fputc_unlocked('\\', f);
fputc_unlocked(*p, f);
}
fputc_unlocked('\"', f);
} else
fputs_unlocked(p, f);
fputc_unlocked('\n', f);
}
static void cut_bytes(FILE *stream )
{ size_t byte_idx ;
_Bool print_delimiter ;
int c ;
_Bool range_start ;
_Bool *rs ;
_Bool *tmp ;
_Bool tmp___0 ;
{
byte_idx = 0UL;
print_delimiter = (_Bool)0;
while (1) {
c = getc_unlocked(stream);
if (c == 10) {
putchar_unlocked('\n');
byte_idx = 0UL;
print_delimiter = (_Bool)0;
} else {
if (c == -1) {
if (byte_idx > 0UL) {
putchar_unlocked('\n');
} else {
}
break;
} else {
if (output_delimiter_specified) {
tmp = & range_start;
} else {
tmp = (_Bool *)((void *)0);
}
rs = tmp;
byte_idx ++;
tmp___0 = print_kth(byte_idx, rs);
if (tmp___0) {
if (rs) {
if (*rs) {
if (print_delimiter) {
fwrite_unlocked((void const */* __restrict */)output_delimiter_string, sizeof(char ), output_delimiter_length, (FILE */* __restrict */)stdout);
} else {
}
} else {
}
} else {
}
print_delimiter = (_Bool)1;
putchar_unlocked(c);
} else {
}
}
}
}
return;
}
}
int putw(int w, FILE *stream)
{
#define PW &w
/* If w is passed in a register, enable the following. */
#if 0
#undef PW
int PW[1];
PW[0] = w;
#endif
#if EOF == -1
return fwrite_unlocked((void *) PW, sizeof(int), 1, stream) - 1;
#else
return (fwrite_unlocked((void *) PW, sizeof(int), 1, stream) != 0)
? 0 : EOF;
#endif
}
static size_t fwrite_lock(const void* data, size_t size, size_t count, FILE* f)
{
#if HAVE_FWRITE_UNLOCKED
return fwrite_unlocked(data, size, count, f);
#else
return fwrite(data, size, count, f);
#endif
}
static int snappy_in_java_compress(FILE *infp, FILE *outfp, size_t block_size)
{
work_buffer_t wb;
size_t uncompressed_length;
int err = 1;
wb.c = NULL;
wb.uc = NULL;
if (block_size == 0) {
block_size = DEFAULT_BLOCK_SIZE;
}
if (block_size > MAX_BLOCK_SIZE) {
print_error("Too large block size: %lu. (default: %d, max: %d)\n",
(unsigned long)block_size, DEFAULT_BLOCK_SIZE, MAX_BLOCK_SIZE);
goto cleanup;
}
if (fwrite_unlocked(&snappy_in_java_header, sizeof(snappy_in_java_header), 1, outfp) != 1) {
print_error("Failed to write a file: %s\n", strerror(errno));
goto cleanup;
}
/* write file body */
work_buffer_init(&wb, block_size);
while ((uncompressed_length = fread_unlocked(wb.uc, 1, wb.uclen, infp)) > 0) {
size_t compressed_length = wb.clen;
unsigned int crc32c = masked_crc32c(wb.uc, uncompressed_length);
trace("read %lu bytes.\n", (unsigned long)uncompressed_length);
/* compress the block. */
snappy_compress(wb.uc, uncompressed_length, wb.c, &compressed_length);
trace("compressed_legnth is %lu.\n", (unsigned long)compressed_length);
if (compressed_length >= (uncompressed_length - (uncompressed_length / 8))) {
trace("write uncompressed data\n");
if (write_block(outfp, wb.uc, uncompressed_length, FALSE, crc32c) != 0) {
goto cleanup;
}
} else {
trace("write compressed data\n");
if (write_block(outfp, wb.c, compressed_length, TRUE, crc32c) != 0) {
goto cleanup;
}
}
}
if (!feof_unlocked(infp)) {
/* fread_unlocked() failed. */
print_error("Failed to read a file: %s\n", strerror(errno));
goto cleanup;
}
err = 0;
cleanup:
work_buffer_free(&wb);
return err;
}
/**
* process_subbufs - write ready subbufs to disk
*/
static int process_subbufs(struct _stp_buf_info *info,
struct switchfile_ctrl_block *scb)
{
unsigned subbufs_ready, start_subbuf, end_subbuf, subbuf_idx, i;
int len, cpu = info->cpu;
char *subbuf_ptr;
int subbufs_consumed = 0;
unsigned padding;
subbufs_ready = info->produced - info->consumed;
start_subbuf = info->consumed % n_subbufs;
end_subbuf = start_subbuf + subbufs_ready;
for (i = start_subbuf; i < end_subbuf; i++) {
subbuf_idx = i % n_subbufs;
subbuf_ptr = relay_buffer[cpu] + subbuf_idx * subbuf_size;
padding = *((unsigned *)subbuf_ptr);
subbuf_ptr += sizeof(padding);
len = (subbuf_size - sizeof(padding)) - padding;
scb->wsize += len;
if (fsize_max && scb->wsize > fsize_max) {
if (switch_oldoutfile(cpu, scb) < 0) {
perr("Couldn't open file for cpu %d, exiting.", cpu);
return -1;
}
scb->wsize = len;
}
if (len) {
#ifdef __ANDROID__
if (fwrite (subbuf_ptr, len, 1, percpu_tmpfile[cpu]) != 1) {
#else
if (fwrite_unlocked (subbuf_ptr, len, 1, percpu_tmpfile[cpu]) != 1) {
#endif
if (errno != EPIPE)
_perr("Couldn't write to output file for cpu %d, exiting:", cpu);
return -1;
}
}
subbufs_consumed++;
}
return subbufs_consumed;
}
/**
* reader_thread - per-cpu channel buffer reader
*/
static void *reader_thread(void *data)
{
int rc;
int cpu = (long)data;
struct pollfd pollfd;
struct _stp_consumed_info consumed_info;
unsigned subbufs_consumed;
cpu_set_t cpu_mask;
struct timespec tim = {.tv_sec=0, .tv_nsec=200000000}, *timeout = &tim;
void use_fwrite_unlocked() {
flockfile(stdout);
const char s1[] = "string='";
const char s2[] = "' count='";
const char s3[] = "'\n";
char buf[100];
fwrite_unlocked(s1, sizeof s1, 1, stdout);
fwrite_unlocked(string, strlen(string), 1, stdout);
fwrite_unlocked(s2, sizeof s2, 1, stdout);
int cnt = snprintf(buf, sizeof buf, "%d", count);
fwrite_unlocked(buf, cnt, 1, stdout);
fwrite_unlocked(s3, sizeof s3, 1, stdout);
funlockfile(stdout);
}
/* Ensure that FS has space for AMOUNT more bytes in its buffer, either by
growing the buffer, or by flushing it. True is returned iff we succeed. */
int
__argp_fmtstream_ensure (struct argp_fmtstream *fs, size_t amount)
{
if ((size_t) (fs->end - fs->p) < amount)
{
ssize_t wrote;
/* Flush FS's buffer. */
__argp_fmtstream_update (fs);
#ifdef USE_IN_LIBIO
if (_IO_fwide (fs->stream, 0) > 0)
{
__fwprintf (fs->stream, L"%.*s", (int) (fs->p - fs->buf), fs->buf);
wrote = fs->p - fs->buf;
}
else
#endif
wrote = fwrite_unlocked (fs->buf, 1, fs->p - fs->buf, fs->stream);
if (wrote == fs->p - fs->buf)
{
fs->p = fs->buf;
fs->point_offs = 0;
}
else
{
fs->p -= wrote;
fs->point_offs -= wrote;
memmove (fs->buf, fs->buf + wrote, fs->p - fs->buf);
return 0;
}
if ((size_t) (fs->end - fs->buf) < amount)
/* Gotta grow the buffer. */
{
size_t new_size = fs->end - fs->buf + amount;
char *new_buf = realloc (fs->buf, new_size);
if (! new_buf)
{
__set_errno (ENOMEM);
return 0;
}
fs->buf = new_buf;
fs->end = new_buf + new_size;
fs->p = fs->buf;
}
}
return 1;
}
void
__bb_exit_func (void)
{
const int version = GMON_VERSION;
struct gmon_hdr ghdr;
struct __bb *ptr;
FILE *fp;
fp = fopen (OUT_NAME, "wb");
if (!fp)
{
perror (OUT_NAME);
return;
}
/* No threads use this stream. */
__fsetlocking (fp, FSETLOCKING_BYCALLER);
memcpy (&ghdr.cookie[0], GMON_MAGIC, 4);
memcpy (&ghdr.version, &version, sizeof (version));
fwrite_unlocked (&ghdr, sizeof (ghdr), 1, fp);
for (ptr = __bb_head; ptr != 0; ptr = ptr->next)
{
u_int ncounts = ptr->ncounts;
u_char tag;
u_int i;
tag = GMON_TAG_BB_COUNT;
fwrite_unlocked (&tag, sizeof (tag), 1, fp);
fwrite_unlocked (&ncounts, sizeof (ncounts), 1, fp);
for (i = 0; i < ncounts; ++i)
{
fwrite_unlocked (&ptr->addresses[i], sizeof (ptr->addresses[0]), 1,
fp);
fwrite_unlocked (&ptr->counts[i], sizeof (ptr->counts[0]), 1, fp);
}
}
fclose (fp);
}
int main() {
fread_unlocked(ibuff, 3000, 1, stdin);
getstr(dump);
test = atoi(dump);
while(test--) {
init();
readSudoku();
solveDLX(0);
if(test) getstr(dump), *out++ = '\n';
}
fwrite_unlocked(obuff, out - obuff, 1, stdout);
return 0;
}
int main (int argc, char *argv[]) {
double C = 60 * log(2);
double PI = 2 * acos(0);
fread_unlocked(s, sizeof(char), 10 * 1024 * 1024, stdin);
readn();
int i, t = n;
for (I = 0; I < t; I += 1) {
readn_signed();
a = n;
readn_signed();
b = n;
theta = atan2 (b, a) / PI;
r = log( (double)( a * a + b * b ) );
written = 1;
for (k = 1; k <= 4; k += 1) {
if ( k * r <= C && fabs ( k * theta - (int)(k * theta + 0.5) ) < 0.00001 ) {
writen(k);
written = 101;
break;
}
}
if ( written != 101 ) {
out[++wcount] = 'T';
out[++wcount] = 'O';
out[++wcount] = 'O';
out[++wcount] = ' ';
out[++wcount] = 'C';
out[++wcount] = 'O';
out[++wcount] = 'M';
out[++wcount] = 'P';
out[++wcount] = 'L';
out[++wcount] = 'I';
out[++wcount] = 'C';
out[++wcount] = 'A';
out[++wcount] = 'T';
out[++wcount] = 'E';
out[++wcount] = 'D';
}
out[++wcount] = '\n';
}
fwrite_unlocked(out, 1, wcount + 1, stdout);
return 0;
}
/* Ensure that FS has space for AMOUNT more bytes in its buffer, either by
growing the buffer, or by flushing it. True is returned iff we succeed. */
int
__argp_fmtstream_ensure (struct argp_fmtstream *fs, size_t amount)
{
if ((size_t) (fs->end - fs->p) < amount)
{
ssize_t wrote;
/* Flush FS's buffer. */
__argp_fmtstream_update (fs);
#ifdef _LIBC
__fxprintf (fs->stream, "%.*s", (int) (fs->p - fs->buf), fs->buf);
wrote = fs->p - fs->buf;
#else
wrote = fwrite_unlocked (fs->buf, 1, fs->p - fs->buf, fs->stream);
#endif
if (wrote == fs->p - fs->buf)
{
fs->p = fs->buf;
fs->point_offs = 0;
}
else
{
fs->p -= wrote;
fs->point_offs -= wrote;
memmove (fs->buf, fs->buf + wrote, fs->p - fs->buf);
return 0;
}
if ((size_t) (fs->end - fs->buf) < amount)
/* Gotta grow the buffer. */
{
size_t old_size = fs->end - fs->buf;
size_t new_size = old_size + amount;
char *new_buf;
if (new_size < old_size || ! (new_buf = realloc (fs->buf, new_size)))
{
__set_errno (ENOMEM);
return 0;
}
fs->buf = new_buf;
fs->end = new_buf + new_size;
fs->p = fs->buf;
}
}
return 1;
}
/* Flush FS to its stream, and free it (but don't close the stream). */
void
__argp_fmtstream_free (argp_fmtstream_t fs)
{
__argp_fmtstream_update (fs);
if (fs->p > fs->buf)
{
#ifdef _LIBC
__fxprintf (fs->stream, "%.*s", (int) (fs->p - fs->buf), fs->buf);
#else
fwrite_unlocked (fs->buf, 1, fs->p - fs->buf, fs->stream);
#endif
}
free (fs->buf);
free (fs);
}
/* Flush FS to its stream, and free it (but don't close the stream). */
void
__argp_fmtstream_free (argp_fmtstream_t fs)
{
__argp_fmtstream_update (fs);
if (fs->p > fs->buf)
{
#ifdef USE_IN_LIBIO
if (_IO_fwide (fs->stream, 0) > 0)
__fwprintf (fs->stream, L"%.*s", (int) (fs->p - fs->buf), fs->buf);
else
#endif
fwrite_unlocked (fs->buf, 1, fs->p - fs->buf, fs->stream);
}
free (fs->buf);
free (fs);
}
int main (int argc, char *argv[]) {
int i;
unsigned int f[77];
f[1] = 1;
f[2] = 2;
f[3] = 2;
for (i = 4; i < 77; i += 1) {
f[i] = f[i - 3] + f[i - 2];
}
fread_unlocked(s, sizeof(char), 10 * 1024, stdin);
readn();
do {
writen(f[n]);
out[++wcount] = '\n';
readn();
} while ( n > 0 );
fwrite_unlocked(out, 1, wcount + 1, stdout);
return 0;
}
static void run_line(const char *p, const char *end, const Corpus &corp)
{
while(p < end)
{
while(p < end && *p == ' ') p++;
const char *start = p;
while(p < end && *p != ' ') p++;
if(p - start > 0)
{
int term_id = corp.lookup(start, p-start);
if(term_id == -1)
fprintf(stderr, "WARNING: term not found: '%.*s'\n", (int)(p-start), start);
else {
uint64_t x = rawpost(term_id, doc_id, term_pos++);
fwrite_unlocked(&x, sizeof(x), 1, stdout);
}
}
}
}
/**
* process_subbufs - write ready subbufs to disk
*/
static int process_subbufs(struct _stp_buf_info *info,
struct switchfile_ctrl_block *scb)
{
unsigned subbufs_ready, start_subbuf, end_subbuf, subbuf_idx, i;
int len, cpu = info->cpu;
char *subbuf_ptr;
int subbufs_consumed = 0;
unsigned padding;
subbufs_ready = info->produced - info->consumed;
start_subbuf = info->consumed % n_subbufs;
end_subbuf = start_subbuf + subbufs_ready;
for (i = start_subbuf; i < end_subbuf; i++) {
subbuf_idx = i % n_subbufs;
subbuf_ptr = relay_buffer[cpu] + subbuf_idx * subbuf_size;
padding = *((unsigned *)subbuf_ptr);
subbuf_ptr += sizeof(padding);
len = (subbuf_size - sizeof(padding)) - padding;
scb->wsize += len;
if (fsize_max && scb->wsize > fsize_max) {
if (switch_oldoutfile(cpu, scb) < 0) {
perr("Couldn't open file for cpu %d, exiting.", cpu);
return -1;
}
scb->wsize = len;
}
if (len) {
if (fwrite_unlocked (subbuf_ptr, len, 1, percpu_tmpfile[cpu]) != 1) {
if (errno != EPIPE)
_perr("Couldn't write to output file for cpu %d, exiting:", cpu);
return -1;
}
}
subbufs_consumed++;
}
return subbufs_consumed;
}
void
repeat(const char *alu, const char *title, int n) {
int len = strlen(alu);
char buffer[len + LINE_LEN];
int pos = 0;
memcpy(buffer, alu, len);
memcpy(buffer + len, alu, LINE_LEN);
fputs_unlocked(title, stdout);
while (n > 0) {
int bytes = n > LINE_LEN ? LINE_LEN : n;
fwrite_unlocked(buffer + pos, bytes, 1, stdout);
pos += bytes;
if (pos > len) {
pos -= len;
}
fputc_unlocked('\n', stdout);
n -= bytes;
}
}
int op_write_debug_line_info(op_agent_t hdl, void const * code,
size_t nr_entry,
struct debug_line_info const * compile_map)
{
struct jr_code_debug_info rec;
long cur_pos, last_pos;
struct timeval tv;
size_t i;
size_t padding_count;
char padd_bytes[7] = {0, 0, 0, 0, 0, 0, 0};
int rc = -1;
FILE * dumpfile = (FILE *) hdl;
if (!dumpfile) {
errno = EINVAL;
fprintf(stderr, "Invalid hdl argument\n");
return -1;
}
/* write nothing if no entries are provided */
if (nr_entry == 0)
return 0;
rec.id = JIT_CODE_DEBUG_INFO;
rec.code_addr = (uint64_t)(uintptr_t)code;
/* will be fixed after writing debug line info */
rec.total_size = 0;
rec.nr_entry = nr_entry;
if (gettimeofday(&tv, NULL)) {
fprintf(stderr, "gettimeofday failed\n");
return -1;
}
rec.timestamp = tv.tv_sec;
flockfile(dumpfile);
if ((cur_pos = ftell(dumpfile)) == -1l)
goto error;
if (!fwrite_unlocked(&rec, sizeof(rec), 1, dumpfile))
goto error;
for (i = 0; i < nr_entry; ++i) {
if (!fwrite_unlocked(&compile_map[i].vma,
sizeof(compile_map[i].vma), 1,
dumpfile) ||
!fwrite_unlocked(&compile_map[i].lineno,
sizeof(compile_map[i].lineno), 1,
dumpfile) ||
!fwrite_unlocked(compile_map[i].filename,
strlen(compile_map[i].filename) + 1, 1,
dumpfile))
goto error;
}
if ((last_pos = ftell(dumpfile)) == -1l)
goto error;
rec.total_size = last_pos - cur_pos;
padding_count = PADDING_8ALIGNED(rec.total_size);
rec.total_size += padding_count;
if (padding_count && !fwrite(padd_bytes, padding_count, 1, dumpfile))
goto error;
if (fseek(dumpfile, cur_pos, SEEK_SET) == -1l)
goto error;
if (!fwrite_unlocked(&rec, sizeof(rec), 1, dumpfile))
goto error;
if (fseek(dumpfile, last_pos + padding_count, SEEK_SET) == -1)
goto error;
rc = 0;
error:
fflush_unlocked(dumpfile);
funlockfile(dumpfile);
return rc;
}
static int snzip_compress(FILE *infp, FILE *outfp, size_t block_size)
{
snz_header_t header;
work_buffer_t wb;
size_t uncompressed_length;
int err = 1;
int nshift;
wb.c = NULL;
wb.uc = NULL;
if (block_size == 0) {
block_size = 1ul << SNZ_DEFAULT_BLOCK_SIZE;
nshift = SNZ_DEFAULT_BLOCK_SIZE;
} else {
if (block_size > (1ul << SNZ_MAX_BLOCK_SIZE)) {
print_error("too large block size: %lu\n", block_size);
goto cleanup;
}
for (nshift = 1; nshift <= SNZ_MAX_BLOCK_SIZE; nshift++) {
if (1ul << nshift == block_size) {
break;
}
}
if (nshift == SNZ_MAX_BLOCK_SIZE) {
print_error("The block size must be power of two\n");
goto cleanup;
}
}
/* write the file header */
memcpy(header.magic, SNZ_MAGIC, SNZ_MAGIC_LEN);
header.version = SNZ_FILE_VERSION;
header.block_size = nshift;
if (fwrite_unlocked(&header, sizeof(header), 1, outfp) != 1) {
print_error("Failed to write a file: %s\n", strerror(errno));
goto cleanup;
}
/* write file body */
work_buffer_init(&wb, block_size);
while ((uncompressed_length = fread_unlocked(wb.uc, 1, wb.uclen, infp)) > 0) {
size_t compressed_length = wb.clen;
trace("read %lu bytes.\n", (unsigned long)uncompressed_length);
/* compress the block. */
snappy_compress(wb.uc, uncompressed_length, wb.c, &compressed_length);
trace("compressed_legnth is %lu.\n", (unsigned long)compressed_length);
/* write the compressed length. */
if (compressed_length < (1ul << 7)) {
putc_unlocked(compressed_length, outfp);
trace("write 1 byte for compressed data length.\n");
} else if (compressed_length < (1ul << 14)) {
putc_unlocked((compressed_length >> 0) | 0x80, outfp);
putc_unlocked((compressed_length >> 7), outfp);
trace("write 2 bytes for compressed data length.\n");
} else if (compressed_length < (1ul << 21)) {
static stream_state_t process_block(FILE *fp, stream_state_t state, block_data_t *bd, char *work, size_t work_len)
{
unsigned int crc32c;
size_t outlen;
switch (state) {
case INITIAL_STATE:
case END_OF_STREAM_STATE:
/* the next block must be a header block. */
if (bd->type != HEADER_TYPE_CODE) {
print_error("Invaid file format\n");
return ERROR_STATE;
}
if (bd->data_len != 6) {
print_error("invalid data length %d for header block\n", bd->data_len);
return ERROR_STATE;
}
if (memcmp(bd->data, "snappy", 6) != 0) {
print_error("invalid file header\n");
return ERROR_STATE;
}
return PROCESSING_STATE;
case PROCESSING_STATE:
switch (bd->type) {
case COMPRESSED_TYPE_CODE:
if (bd->data_len <= 4) {
print_error("too short data length for compressed data block\n");
return ERROR_STATE;
}
crc32c = ((unsigned char)bd->data[0] << 0);
crc32c |= ((unsigned char)bd->data[1] << 8);
crc32c |= ((unsigned char)bd->data[2] << 16);
crc32c |= ((unsigned char)bd->data[3] << 24);
/* uncompress and write */
outlen = work_len;
if (snappy_uncompress(bd->data + 4, bd->data_len - 4, work, &outlen)) {
print_error("Invalid data: RawUncompress failed\n");
return ERROR_STATE;
}
if (crc32c != masked_crc32c(work, outlen)) {
print_error("Invalid data: CRC32c error\n");
return ERROR_STATE;
}
if (fwrite_unlocked(work, outlen, 1, fp) != 1) {
print_error("Failed to write: %s\n", strerror(errno));
return ERROR_STATE;
}
break;
case UNCOMPRESSED_TYPE_CODE:
if (bd->data_len <= 4) {
print_error("too short data length for uncompressed data block\n");
return ERROR_STATE;
}
crc32c = ((unsigned char)bd->data[0] << 0);
crc32c |= ((unsigned char)bd->data[1] << 8);
crc32c |= ((unsigned char)bd->data[2] << 16);
crc32c |= ((unsigned char)bd->data[3] << 24);
if (crc32c != masked_crc32c(bd->data + 4, bd->data_len - 4)) {
print_error("Invalid data: CRC32c error\n");
return ERROR_STATE;
}
if (fwrite_unlocked(bd->data + 4, bd->data_len - 4, 1, fp) != 1) {
print_error("Failed to write: %s\n", strerror(errno));
return ERROR_STATE;
}
break;
case END_OF_STREAM_TYPE_CODE:
if (bd->data_len != 0) {
print_error("invalid data length for end-of-stream block\n");
return ERROR_STATE;
}
return END_OF_STREAM_STATE;
case HEADER_TYPE_CODE:
print_error("Invalid data: unexpected header\n");
return ERROR_STATE;
default:
if (bd->type < 0x80) {
print_error("Invalid data: unknown block type %d\n", bd->type);
return ERROR_STATE;
}
}
return PROCESSING_STATE;
case ERROR_STATE:
;
}
/* never reach here. This is added to suppress a warning */
return ERROR_STATE;
}
/* Process FS's buffer so that line wrapping is done from POINT_OFFS to the
end of its buffer. This code is mostly from glibc stdio/linewrap.c. */
void
__argp_fmtstream_update (argp_fmtstream_t fs)
{
char *buf, *nl;
size_t len;
/* Scan the buffer for newlines. */
buf = fs->buf + fs->point_offs;
while (buf < fs->p)
{
size_t r;
if (fs->point_col == 0 && fs->lmargin != 0)
{
/* We are starting a new line. Print spaces to the left margin. */
const size_t pad = fs->lmargin;
if (fs->p + pad < fs->end)
{
/* We can fit in them in the buffer by moving the
buffer text up and filling in the beginning. */
memmove (buf + pad, buf, fs->p - buf);
fs->p += pad; /* Compensate for bigger buffer. */
memset (buf, ' ', pad); /* Fill in the spaces. */
buf += pad; /* Don't bother searching them. */
}
else
{
/* No buffer space for spaces. Must flush. */
size_t i;
for (i = 0; i < pad; i++)
{
#ifdef _LIBC
if (_IO_fwide (fs->stream, 0) > 0)
{
#if ! _LIBC || __OPTION_POSIX_WIDE_CHAR_DEVICE_IO
putwc_unlocked (L' ', fs->stream);
#else
abort ();
#endif
}
else
#endif
putc_unlocked (' ', fs->stream);
}
}
fs->point_col = pad;
}
len = fs->p - buf;
nl = memchr (buf, '\n', len);
if (fs->point_col < 0)
fs->point_col = 0;
if (!nl)
{
/* The buffer ends in a partial line. */
if (fs->point_col + len < fs->rmargin)
{
/* The remaining buffer text is a partial line and fits
within the maximum line width. Advance point for the
characters to be written and stop scanning. */
fs->point_col += len;
break;
}
else
/* Set the end-of-line pointer for the code below to
the end of the buffer. */
nl = fs->p;
}
else if (fs->point_col + (nl - buf) < (ssize_t) fs->rmargin)
{
/* The buffer contains a full line that fits within the maximum
line width. Reset point and scan the next line. */
fs->point_col = 0;
buf = nl + 1;
continue;
}
/* This line is too long. */
r = fs->rmargin - 1;
if (fs->wmargin < 0)
{
/* Truncate the line by overwriting the excess with the
newline and anything after it in the buffer. */
if (nl < fs->p)
{
memmove (buf + (r - fs->point_col), nl, fs->p - nl);
fs->p -= buf + (r - fs->point_col) - nl;
/* Reset point for the next line and start scanning it. */
fs->point_col = 0;
buf += r + 1; /* Skip full line plus \n. */
}
else
{
/* The buffer ends with a partial line that is beyond the
maximum line width. Advance point for the characters
written, and discard those past the max from the buffer. */
fs->point_col += len;
fs->p -= fs->point_col - r;
break;
}
}
else
{
/* Do word wrap. Go to the column just past the maximum line
width and scan back for the beginning of the word there.
Then insert a line break. */
char *p, *nextline;
int i;
p = buf + (r + 1 - fs->point_col);
while (p >= buf && !isblank (*p))
--p;
nextline = p + 1; /* This will begin the next line. */
if (nextline > buf)
{
/* Swallow separating blanks. */
if (p >= buf)
do
--p;
while (p >= buf && isblank (*p));
nl = p + 1; /* The newline will replace the first blank. */
}
else
{
/* A single word that is greater than the maximum line width.
Oh well. Put it on an overlong line by itself. */
p = buf + (r + 1 - fs->point_col);
/* Find the end of the long word. */
do
++p;
while (p < nl && !isblank (*p));
if (p == nl)
{
/* It already ends a line. No fussing required. */
fs->point_col = 0;
buf = nl + 1;
continue;
}
/* We will move the newline to replace the first blank. */
nl = p;
/* Swallow separating blanks. */
do
++p;
while (isblank (*p));
/* The next line will start here. */
nextline = p;
}
/* Note: There are a bunch of tests below for
NEXTLINE == BUF + LEN + 1; this case is where NL happens to fall
at the end of the buffer, and NEXTLINE is in fact empty (and so
we need not be careful to maintain its contents). */
if ((nextline == buf + len + 1
? fs->end - nl < fs->wmargin + 1
: nextline - (nl + 1) < fs->wmargin)
&& fs->p > nextline)
{
/* The margin needs more blanks than we removed. */
if (fs->end - fs->p > fs->wmargin + 1)
/* Make some space for them. */
{
size_t mv = fs->p - nextline;
memmove (nl + 1 + fs->wmargin, nextline, mv);
nextline = nl + 1 + fs->wmargin;
len = nextline + mv - buf;
*nl++ = '\n';
}
else
/* Output the first line so we can use the space. */
{
#ifdef _LIBC
__fxprintf (fs->stream, "%.*s\n",
(int) (nl - fs->buf), fs->buf);
#else
if (nl > fs->buf)
fwrite_unlocked (fs->buf, 1, nl - fs->buf, fs->stream);
putc_unlocked ('\n', fs->stream);
#endif
len += buf - fs->buf;
nl = buf = fs->buf;
}
}
else
/* We can fit the newline and blanks in before
the next word. */
*nl++ = '\n';
if (nextline - nl >= fs->wmargin
|| (nextline == buf + len + 1 && fs->end - nextline >= fs->wmargin))
/* Add blanks up to the wrap margin column. */
for (i = 0; i < fs->wmargin; ++i)
*nl++ = ' ';
else
for (i = 0; i < fs->wmargin; ++i)
#ifdef _LIBC
if (_IO_fwide (fs->stream, 0) > 0)
{
#ifdef OPTION_POSIX_WIDE_CHAR_DEVICE_IO
putwc_unlocked (L' ', fs->stream);
#else
abort ();
#endif
}
else
#endif
putc_unlocked (' ', fs->stream);
/* Copy the tail of the original buffer into the current buffer
position. */
if (nl < nextline)
memmove (nl, nextline, buf + len - nextline);
len -= nextline - buf;
/* Continue the scan on the remaining lines in the buffer. */
buf = nl;
/* Restore bufp to include all the remaining text. */
fs->p = nl + len;
/* Reset the counter of what has been output this line. If wmargin
is 0, we want to avoid the lmargin getting added, so we set
point_col to a magic value of -1 in that case. */
fs->point_col = fs->wmargin ? fs->wmargin : -1;
}
}
/* Remember that we've scanned as far as the end of the buffer. */
fs->point_offs = fs->p - fs->buf;
}
static int comment_43_compress(FILE *infp, FILE *outfp, size_t block_size)
{
const size_t max_raw_data_len = 32 * 1024; /* maximum data length */
const size_t max_compressed_data_len = snappy_max_compressed_length(max_raw_data_len); /* maximum compressed length */
size_t raw_data_len;
size_t compressed_data_len;
char *raw_data = malloc(max_raw_data_len);
char *compressed_data = malloc(max_compressed_data_len);
int err = 1;
if (raw_data == NULL || compressed_data == NULL) {
print_error("out of memory\n");
goto cleanup;
}
putc_unlocked(HEADER_TYPE_CODE, outfp);
putc_unlocked(MAGIC_LEN, outfp);
putc_unlocked(MAGIC_LEN >> 8, outfp);
fwrite_unlocked(MAGIC, MAGIC_LEN, 1, outfp);
/* write file body */
while ((raw_data_len = fread_unlocked(raw_data, 1, max_raw_data_len, infp)) > 0) {
unsigned int crc32c = masked_crc32c(raw_data, raw_data_len);
char type_code;
size_t write_len;
const char *write_data;
/* compress the block. */
compressed_data_len = max_compressed_data_len;
snappy_compress(raw_data, raw_data_len, compressed_data, &compressed_data_len);
if (compressed_data_len >= (raw_data_len - (raw_data_len / 8))) {
/* write uncompressed data */
type_code = UNCOMPRESSED_TYPE_CODE;
write_len = raw_data_len;
write_data = raw_data;
} else {
/* write compressed data */
type_code = COMPRESSED_TYPE_CODE;
write_len = compressed_data_len;
write_data = compressed_data;
}
/* block type */
putc_unlocked(type_code, outfp);
/* data length */
putc_unlocked(((write_len + 4) >> 0), outfp);
putc_unlocked(((write_len + 4) >> 8), outfp);
/* data */
putc_unlocked((crc32c >> 0), outfp);
putc_unlocked((crc32c >> 8), outfp);
putc_unlocked((crc32c >> 16), outfp);
putc_unlocked((crc32c >> 24), outfp);
if (fwrite_unlocked(write_data, write_len, 1, outfp) != 1) {
print_error("Failed to write a file: %s\n", strerror(errno));
goto cleanup;
}
}
if (!feof_unlocked(infp)) {
/* fread_unlocked() failed. */
print_error("Failed to read a file: %s\n", strerror(errno));
goto cleanup;
}
putc_unlocked(END_OF_STREAM_TYPE_CODE, outfp);
putc_unlocked(0, outfp);
putc_unlocked(0, outfp);
if (ferror_unlocked(outfp)) {
print_error("Failed to write a file: %s\n", strerror(errno));
goto cleanup;
}
err = 0;
cleanup:
free(raw_data);
free(compressed_data);
return err;
}
static int
do_test (void)
{
const char blah[] = "BLAH";
char buf[strlen (blah) + 1];
FILE *fp, *f;
const char *cp;
char *wp;
if ((fp = fdopen (fd, "w+")) == NULL)
exit (1);
flockfile (fp);
f = fp;
cp = blah;
if (ftello (fp) != 0
|| fwrite_unlocked (blah, blah - blah, strlen (blah), f++) != 0
|| f != fp + 1
|| fwrite_unlocked ("", 5.0, 0, --f) != 0
|| f != fp
|| fwrite_unlocked (cp++, 16, 0.25, fp) != 0
|| cp != blah + 1
|| fwrite_unlocked (--cp, 0.25, 16, fp) != 0
|| cp != blah
|| fwrite_unlocked (blah, 0, -0.0, fp) != 0
|| ftello (fp) != 0)
{
puts ("One of fwrite_unlocked tests failed");
exit (1);
}
if (fwrite_unlocked (blah, 1, strlen (blah) - 2, fp) != strlen (blah) - 2)
{
puts ("Could not write string into file");
exit (1);
}
if (putc_unlocked ('A' + 0x1000000, fp) != 'A')
{
puts ("putc_unlocked failed");
exit (1);
}
f = fp;
cp = blah + strlen (blah) - 1;
if (putc_unlocked (*cp++, f++) != 'H'
|| f != fp + 1
|| cp != strchr (blah, '\0'))
{
puts ("fputc_unlocked failed");
exit (1);
}
if (ftello (fp) != (off_t) strlen (blah))
{
printf ("Failed to write %zd bytes to temporary file", strlen (blah));
exit (1);
}
rewind (fp);
f = fp;
wp = buf;
memset (buf, ' ', sizeof (buf));
if (ftello (fp) != 0
|| fread_unlocked (buf, buf - buf, strlen (blah), f++) != 0
|| f != fp + 1
|| fread_unlocked (buf, 5.0, 0, --f) != 0
|| f != fp
|| fread_unlocked (wp++, 16, 0.25, fp) != 0
|| wp != buf + 1
|| fread_unlocked (--wp, 0.25, 16, fp) != 0
|| wp != buf
|| fread_unlocked (buf, 0, -0.0, fp) != 0
|| ftello (fp) != 0
|| memcmp (buf, " ", sizeof (buf)) != 0)
{
puts ("One of fread_unlocked tests failed");
exit (1);
}
if (fread_unlocked (buf, 1, strlen (blah) - 2, fp) != strlen (blah) - 2)
{
puts ("Could not read string from file");
exit (1);
}
if (getc_unlocked (fp) != 'A')
{
puts ("getc_unlocked failed");
exit (1);
}
f = fp;
if (fgetc_unlocked (f++) != 'H'
|| f != fp + 1
|| fgetc_unlocked (--f) != EOF
|| f != fp)
{
puts ("fgetc_unlocked failed");
exit (1);
}
if (ftello (fp) != (off_t) strlen (blah))
{
printf ("Failed to read %zd bytes from temporary file", strlen (blah));
exit (1);
}
funlockfile (fp);
fclose (fp);
return 0;
}
