static int __dsos__write_buildid_table(struct list_head *head, pid_t pid, u16 misc, int fd) { struct dso *pos; dsos__for_each_with_build_id(pos, head) { int err; struct build_id_event b; size_t len; if (!pos->hit) continue; len = pos->long_name_len + 1; len = ALIGN(len, NAME_ALIGN); memset(&b, 0, sizeof(b)); memcpy(&b.build_id, pos->build_id, sizeof(pos->build_id)); b.pid = pid; b.header.misc = misc; b.header.size = sizeof(b) + len; err = do_write(fd, &b, sizeof(b)); if (err < 0) return err; err = write_padded(fd, pos->long_name, pos->long_name_len + 1, len); if (err < 0) return err; }
/** * Print a formatted string * * @param fmt Formatted string * @param ap Variable argument * @param vph Print handler * @param arg Handler argument * * @return 0 if success, otherwise errorcode * * Extensions: * * <pre> * %b (char *, size_t) Buffer string with pointer and length * %r (struct pl) Pointer-length object * %w (uint8_t *, size_t) Binary buffer to hexadecimal format * %j (struct sa *) Socket address - address part only * %J (struct sa *) Socket address and port - like 1.2.3.4:1234 * %H (re_printf_h *, void *) Print handler with argument * %v (char *fmt, va_list *) Variable argument list * %m (int) Describe an error code * </pre> * * Reserved for the future: * * %k * %y * */ int re_vhprintf(const char *fmt, va_list ap, re_vprintf_h *vph, void *arg) { uint8_t base, *bptr; char pch, ch, num[NUM_SIZE], addr[64], msg[256]; enum length_modifier lenmod = LENMOD_NONE; struct re_printf pf; bool fm = false, plr = false; const struct pl *pl; size_t pad = 0, fpad = -1, len, i; const char *str, *p = fmt, *p0 = fmt; const struct sa *sa; re_printf_h *ph; void *ph_arg; va_list *apl; int err = 0; void *ptr; uint64_t n; int64_t sn; bool uc = false; double dbl; if (!fmt || !vph) return EINVAL; pf.vph = vph; pf.arg = arg; for (;*p && !err; p++) { if (!fm) { if (*p != '%') continue; pch = ' '; plr = false; pad = 0; fpad = -1; lenmod = LENMOD_NONE; uc = false; if (p > p0) err |= vph(p0, p - p0, arg); fm = true; continue; } fm = false; base = 10; switch (*p) { case '-': plr = true; fm = true; break; case '.': fpad = pad; pad = 0; fm = true; break; case '%': ch = '%'; err |= vph(&ch, 1, arg); break; case 'b': str = va_arg(ap, const char *); len = va_arg(ap, size_t); err |= write_padded(str, str ? len : 0, pad, ' ', plr, NULL, vph, arg); break; case 'c': ch = va_arg(ap, int); err |= write_padded(&ch, 1, pad, ' ', plr, NULL, vph, arg); break; case 'd': case 'i': switch (lenmod) { case LENMOD_SIZE: sn = va_arg(ap, ssize_t); break; default: case LENMOD_LONG_LONG: sn = va_arg(ap, signed long long); break; case LENMOD_LONG: sn = va_arg(ap, signed long); break; case LENMOD_NONE: sn = va_arg(ap, signed); break; } len = local_itoa(num, (sn < 0) ? -sn : sn, base, false); err |= write_padded(num, len, pad, plr ? ' ' : pch, plr, (sn < 0) ? prfx_neg : NULL, vph, arg); break; case 'f': case 'F': dbl = va_arg(ap, double); if (fpad == (size_t)-1) { fpad = pad; pad = 0; } if (isinf(dbl)) { err |= write_padded("inf", 3, fpad, ' ', plr, NULL, vph, arg); } else if (isnan(dbl)) { err |= write_padded("nan", 3, fpad, ' ', plr, NULL, vph, arg); } else { len = local_ftoa(num, dbl, pad ? min(pad, DEC_SIZE) : 6); err |= write_padded(num, len, fpad, plr ? ' ' : pch, plr, (dbl<0) ? prfx_neg : NULL, vph, arg); } break; case 'H': ph = va_arg(ap, re_printf_h *); ph_arg = va_arg(ap, void *); if (ph) err |= ph(&pf, ph_arg); break; case 'l': ++lenmod; fm = true; break; case 'm': str = str_error(va_arg(ap, int), msg, sizeof(msg)); err |= write_padded(str, str_len(str), pad, ' ', plr, NULL, vph, arg); break; case 'p': ptr = va_arg(ap, void *); if (ptr) { len = local_itoa(num, (unsigned long int)ptr, 16, false); err |= write_padded(num, len, pad, plr ? ' ' : pch, plr, prfx_hex, vph, arg); } else { err |= write_padded(str_nil, sizeof(str_nil) - 1, pad, ' ', plr, NULL, vph, arg); } break; case 'r': pl = va_arg(ap, const struct pl *); err |= write_padded(pl ? pl->p : NULL, (pl && pl->p) ? pl->l : 0, pad, ' ', plr, NULL, vph, arg); break; case 's': str = va_arg(ap, const char *); err |= write_padded(str, str_len(str), pad, ' ', plr, NULL, vph, arg); break; case 'X': uc = true; /*@fallthrough@*/ case 'x': base = 16; /*@fallthrough@*/ case 'u': switch (lenmod) { case LENMOD_SIZE: n = va_arg(ap, size_t); break; default: case LENMOD_LONG_LONG: n = va_arg(ap, unsigned long long); break; case LENMOD_LONG: n = va_arg(ap, unsigned long); break; case LENMOD_NONE: n = va_arg(ap, unsigned); break; } len = local_itoa(num, n, base, uc); err |= write_padded(num, len, pad, plr ? ' ' : pch, plr, NULL, vph, arg); break; case 'v': str = va_arg(ap, char *); apl = va_arg(ap, va_list *); if (!str || !apl) break; err |= re_vhprintf(str, *apl, vph, arg); break; case 'W': uc = true; /*@fallthrough@*/ case 'w': bptr = va_arg(ap, uint8_t *); len = va_arg(ap, size_t); len = bptr ? len : 0; pch = plr ? ' ' : pch; while (!plr && pad-- > (len * 2)) err |= vph(&pch, 1, arg); for (i=0; i<len; i++) { const uint8_t v = *bptr++; uint32_t l = local_itoa(num, v, 16, uc); err |= write_padded(num, l, 2, '0', false, NULL, vph, arg); } while (plr && pad-- > (len * 2)) err |= vph(&pch, 1, arg); break; case 'z': lenmod = LENMOD_SIZE; fm = true; break; case 'j': sa = va_arg(ap, struct sa *); if (!sa) break; if (sa_ntop(sa, addr, sizeof(addr))) { err |= write_padded("?", 1, pad, ' ', plr, NULL, vph, arg); break; } err |= write_padded(addr, strlen(addr), pad, ' ', plr, NULL, vph, arg); break; case 'J': sa = va_arg(ap, struct sa *); if (!sa) break; if (sa_ntop(sa, addr, sizeof(addr))) { err |= write_padded("?", 1, pad, ' ', plr, NULL, vph, arg); break; } #ifdef HAVE_INET6 if (AF_INET6 == sa_af(sa)) { ch = '['; err |= vph(&ch, 1, arg); } #endif err |= write_padded(addr, strlen(addr), pad, ' ', plr, NULL, vph, arg); #ifdef HAVE_INET6 if (AF_INET6 == sa_af(sa)) { ch = ']'; err |= vph(&ch, 1, arg); } #endif ch = ':'; err |= vph(&ch, 1, arg); len = local_itoa(num, sa_port(sa), 10, false); err |= write_padded(num, len, pad, plr ? ' ' : pch, plr, NULL, vph, arg); break; default: if (('0' <= *p) && (*p <= '9')) { if (!pad && ('0' == *p)) { pch = '0'; } else { pad *= 10; pad += *p - '0'; } fm = true; break; } ch = '?'; err |= vph(&ch, 1, arg); break; } if (!fm) p0 = p + 1; } if (!fm && p > p0) err |= vph(p0, p - p0, arg); return err; }
int main( int agrc, char** argv ) { uint8_t *raw; char *filename = argv[1]; image_width = atoi( argv[2] ); image_height = atoi( argv[3] ); printf( "%s %d %d\n", filename, image_width, image_height ); stride = image_width+2; raw = read_raw( filename ); write_padded( "padded.raw", raw ); uint8_t *blurred = malloc( stride*(image_height+2)*4 ); clock_t start = clock(); /* Box Blur applied 3 times is extremely similar to Gaussian blur */ for ( int y = 0; y < image_height+2; y++ ) { for ( int x = 0; x < stride; x++ ) { average_neighbors( raw, blurred, x, y ); } } for ( int y = 0; y < image_height+2; y++ ) { for ( int x = 0; x < stride; x++ ) { average_neighbors( blurred, blurred, x, y ); } } for ( int y = 0; y < image_height+2; y++ ) { for ( int x = 0; x < stride; x++ ) { average_neighbors( blurred, blurred, x, y ); } } clock_t end = clock(); float seconds = (float)(end - start) / CLOCKS_PER_SEC; printf( "Regular box blur took %f seconds\n", seconds ); write_raw( "blurred.raw", blurred ); start = clock(); memset( blurred, 0, stride*(image_height+2)*4 ); /* Box Blur applied 3 times is extremely similar to Gaussian blur */ for ( int y = 0; y < image_height+2; y++ ) { for ( int x = 0; x < stride; x+=2 ) { average_neighbors_simd( raw, blurred, x, y ); } } for ( int y = 0; y < image_height+2; y++ ) { for ( int x = 0; x < stride; x+=2 ) { average_neighbors_simd( blurred, blurred, x, y ); } } for ( int y = 0; y < image_height+2; y++ ) { for ( int x = 0; x < stride; x+=2 ) { average_neighbors_simd( blurred, blurred, x, y ); } } end = clock(); seconds = (float)(end - start) / CLOCKS_PER_SEC; printf( "SIMD blur took %f seconds\n", seconds ); write_raw( "blurred_simd.raw", blurred ); start = clock(); memset( blurred, 0, stride*(image_height+2)*4 ); for ( int y = 0; y < image_height+2; y++ ) { for ( int x = 0; x < stride; x++ ) { grayscale( raw, blurred, x, y ); } } end = clock(); seconds = (float)(end - start) / CLOCKS_PER_SEC; printf( "grayscale took %f seconds\n", seconds ); write_raw( "grayscale.raw", blurred ); start = clock(); memset( blurred, 0, stride*(image_height+2)*4 ); for ( int y = 0; y < image_height+2; y++ ) { for ( int x = 0; x < stride; x+=8 ) { grayscale_simd( raw, blurred, x, y ); } } end = clock(); seconds = (float)(end - start) / CLOCKS_PER_SEC; printf( "grayscale SIMD took %f seconds\n", seconds ); write_raw( "grayscale_simd.raw", blurred ); start = clock(); memset( blurred, 0, stride*(image_height+2)*4 ); for ( int y = 0; y < image_height+2; y++ ) { for ( int x = 0; x < stride; x++ ) { sharpen( raw, blurred, x, y ); } } end = clock(); seconds = (float)(end - start) / CLOCKS_PER_SEC; printf( "sharpen took %f seconds\n", seconds ); write_raw( "sharpen.raw", blurred ); start = clock(); memset( blurred, 0, stride*(image_height+2)*4 ); for ( int y = 0; y < image_height+2; y++ ) { for ( int x = 0; x < stride; x++ ) { sharpen_simd( raw, blurred, x, y ); } } end = clock(); seconds = (float)(end - start) / CLOCKS_PER_SEC; printf( "sharpen SIMD took %f seconds\n", seconds ); write_raw( "sharpen_simd.raw", blurred ); free( raw ); free( blurred ); return 0; }