Raw paste - Back to the pastebin


  1. /*

  2. This software is released into public domain.

  3. It is provided "as is", without warranties or conditions of any kind.

  4. Anyone is free to use, modify, redistribute and do anything with this software.

  5. 

  6. All echo functions in here work as if the parameter -e was provided.

  7. */

  8. 

  9. #define _POSIX_SOURCE /* putchar_unlocked */

  10. 

  11. #include <inttypes.h>

  12. #include <fcntl.h>

  13. #include <stdbool.h>

  14. #include <stdint.h>

  15. #include <stdio.h>

  16. #include <stdlib.h>

  17. #include <string.h>

  18. #include <sys/time.h>

  19. #include <unistd.h>

  20. 

  21. #ifndef NITER

  22. #define NITER 1000000

  23. #endif

  24. 

  25. typedef void (*func)(void);

  26. typedef void (*echo_func)(int argc, char **argv);

  27. 

  28. int64_t bench(func f, int niter);

  29. 

  30. void test_init(int argc, char **argv);

  31. void test_free(void);

  32. void test_echo(echo_func echo);

  33. 

  34. void test_null(void);

  35. void test_buf(void);

  36. void test_inplace(void);

  37. void test_finplace(void);

  38. void test_putchar(void);

  39. void test_putcharu(void);

  40. void test_write(void);

  41. 

  42. void echo_null(int argc, char **argv);

  43. void echo_buf(int argc, char **argv);

  44. void echo_inplace(int argc, char **argv);

  45. void echo_finplace(int argc, char **argv);

  46. void echo_putchar(int argc, char **argv);

  47. void echo_putcharu(int argc, char **argv);

  48. void echo_write(int argc, char **argv);

  49. 

  50. size_t echo_unescape(char *dst, const char *src);

  51. 

  52. int argc_orig;

  53. char **argv_orig;

  54. char **argv_cpy;

  55. char **argv_echo;

  56. 

  57. int64_t bench(func f, int niter)

  58. {

  59. 	struct timeval start, end;

  60. 

  61. 	gettimeofday(&start, NULL);

  62. 

  63. 	while (niter--) {

  64. 		f();

  65. 	}

  66. 

  67. 	gettimeofday(&end, NULL);

  68. 

  69. 	return (end.tv_sec-start.tv_sec)*1000000 + (end.tv_usec-start.tv_usec);

  70. }

  71. 

  72. void test_init(int argc, char **argv)

  73. {

  74. 	int i;

  75. 

  76. 	argc_orig = argc;

  77. 	argv_orig = argv;

  78. 	argv_cpy = malloc(sizeof(*argv) * (argc+1));

  79. 	if (!argv_cpy) {

  80. 		abort();

  81. 	}

  82. 	argv_cpy[argc] = NULL;

  83. 	argv_echo = malloc(sizeof(*argv) * (argc+1));

  84. 	if (!argv_echo) {

  85. 		abort();

  86. 	}

  87. 	argv_echo[argc] = NULL;

  88. 	for (i=0; i<argc; ++i) {

  89. 		argv_cpy[i] = malloc(strlen(argv[i])+1);

  90. 		if (!argv_cpy[i]) {

  91. 			abort();

  92. 		}

  93. 		strcpy(argv_cpy[i], argv[i]);

  94. 		argv_echo[i] = argv_cpy[i];

  95. 	}

  96. }

  97. 

  98. void test_free(void)

  99. {

  100. 	int i;

  101. 

  102. 	for (i=0; i<argc_orig; ++i) {

  103. 		free(argv_cpy[i]);

  104. 	}

  105. 	free(argv_cpy);

  106. 	free(argv_echo);

  107. }

  108. 

  109. void test_echo(echo_func echo)

  110. {

  111. 	int argc = argc_orig;

  112. 

  113. 	echo(argc, argv_echo);

  114. 

  115. 	while (argc--) {

  116. 		argv_echo[argc] = strcpy(argv_cpy[argc], argv_orig[argc]);

  117. 	}

  118. }

  119. 

  120. void test_null(void) {

  121. 	test_echo(echo_null);

  122. }

  123. 

  124. void test_buf(void) {

  125. 	test_echo(echo_buf);

  126. }

  127. 

  128. void test_inplace(void) {

  129. 	test_echo(echo_inplace);

  130. }

  131. 

  132. void test_finplace(void) {

  133. 	test_echo(echo_finplace);

  134. }

  135. 

  136. void test_putchar(void) {

  137. 	test_echo(echo_putchar);

  138. }

  139. 

  140. void test_putcharu(void) {

  141. 	test_echo(echo_putcharu);

  142. }

  143. 

  144. void test_write(void) {

  145. 	test_echo(echo_write);

  146. }

  147. 

  148. /* do nothing to see how long benchmarking itself takes */

  149. void echo_null(int argc, char **argv) {}

  150. 

  151. /* allocate a buffer, format args into it, use single write() call */

  152. void echo_buf(int argc, char **argv)

  153. {

  154. 	size_t len, n;

  155. 	int i;

  156. 	char *buf;

  157. 

  158. 	len = 0;

  159. 	for (i=0; i<argc; ++i) {

  160. 		len += strlen(argv[i]) + 1;

  161. 	}

  162. 

  163. 	buf = malloc(len);

  164. 	if (!buf) {

  165. 		abort();

  166. 	}

  167. 

  168. 	n = 0;

  169. 	for (i=0; i<argc; ++i) {

  170. 		n += echo_unescape(buf+n, argv[i]);

  171. 		buf[n++] = ' ';

  172. 	}

  173. 	buf[n-1] = '\n';

  174. 

  175. 	write(1, buf, n);

  176. 	free(buf);

  177. }

  178. 

  179. /* does in-place formatting of arguments, write()s each one separately */

  180. void echo_inplace(int argc, char **argv)

  181. {

  182. 	size_t n;

  183. 

  184. 	while (*argv) {

  185. 		n = echo_unescape(*argv, *argv);

  186. 		(*argv)[n++] = argv[1] ? ' ' : '\n';

  187. 		write(1, *argv++, n);

  188. 	}

  189. }

  190. 

  191. /* does in-place formatting of arguments, fwrite each one separately */

  192. void echo_finplace(int argc, char **argv)

  193. {

  194. 	size_t n;

  195. 

  196. 	while (*argv) {

  197. 		n = echo_unescape(*argv, *argv);

  198. 		(*argv)[n++] = argv[1] ? ' ' : '\n';

  199. 		fwrite(*argv++, 1, n, stdout);

  200. 	}

  201. 	fflush(stdout);

  202. }

  203. 

  204. /* uses putchar() for each character */

  205. void echo_putchar(int argc, char **argv)

  206. {

  207. 	bool escape;

  208. 	

  209. 	escape = false;

  210. 	while (*argv) {

  211. 		while (**argv) {

  212. 			if (escape) {

  213. 				switch (**argv) {

  214. 					case 'a':

  215. 						putchar('\a');

  216. 						break;

  217. 					case 'b':

  218. 						putchar('\b');

  219. 						break;

  220. 					case 'f':

  221. 						putchar('\f');

  222. 						break;

  223. 					case 'n':

  224. 						putchar('\n');

  225. 						break;

  226. 					case 'r':

  227. 						putchar('\r');

  228. 						break;

  229. 					case 't':

  230. 						putchar('\t');

  231. 						break;

  232. 					case 'v':

  233. 						putchar('\v');

  234. 						break;

  235. 					/* \xHH and \0ooo would come here */

  236. 					default:

  237. 						putchar(**argv);

  238. 						break;

  239. 				}

  240. 				escape = false;

  241. 			} else {

  242. 				if (**argv == '\\') {

  243. 					escape = true;

  244. 				} else {

  245. 					putchar(**argv);

  246. 				}

  247. 			}

  248. 			++*argv;

  249. 		}

  250. 		putchar(argv[1] ? ' ' : '\n');

  251. 		++argv;

  252. 	}

  253. 	fflush(stdout);

  254. }

  255. 

  256. /* uses putchar_unlocked() for each character */

  257. void echo_putcharu(int argc, char **argv)

  258. {

  259. 	bool escape;

  260. 	

  261. 	escape = false;

  262. 	while (*argv) {

  263. 		while (**argv) {

  264. 			if (escape) {

  265. 				switch (**argv) {

  266. 					case 'a':

  267. 						putchar_unlocked('\a');

  268. 						break;

  269. 					case 'b':

  270. 						putchar_unlocked('\b');

  271. 						break;

  272. 					case 'f':

  273. 						putchar_unlocked('\f');

  274. 						break;

  275. 					case 'n':

  276. 						putchar_unlocked('\n');

  277. 						break;

  278. 					case 'r':

  279. 						putchar_unlocked('\r');

  280. 						break;

  281. 					case 't':

  282. 						putchar_unlocked('\t');

  283. 						break;

  284. 					case 'v':

  285. 						putchar_unlocked('\v');

  286. 						break;

  287. 					/* \xHH and \0ooo would come here */

  288. 					default:

  289. 						putchar_unlocked(**argv);

  290. 						break;

  291. 				}

  292. 				escape = false;

  293. 			} else {

  294. 				if (**argv == '\\') {

  295. 					escape = true;

  296. 				} else {

  297. 					putchar_unlocked(**argv);

  298. 				}

  299. 			}

  300. 			++*argv;

  301. 		}

  302. 		putchar_unlocked(argv[1] ? ' ' : '\n');

  303. 		++argv;

  304. 	}

  305. 	fflush(stdout);

  306. }

  307. 

  308. /* uses write() for each character */

  309. void echo_write(int argc, char **argv)

  310. {

  311. 	bool escape;

  312. 	char c;

  313. 	

  314. 	escape = false;

  315. 	while (*argv) {

  316. 		while (**argv) {

  317. 			c = **argv;

  318. 			if (escape) {

  319. 				switch (c) {

  320. 					case 'a':

  321. 						c = '\a';

  322. 						break;

  323. 					case 'b':

  324. 						c = '\b';

  325. 						break;

  326. 					case 'f':

  327. 						c = '\f';

  328. 						break;

  329. 					case 'n':

  330. 						c = '\n';

  331. 						break;

  332. 					case 'r':

  333. 						c = '\r';

  334. 						break;

  335. 					case 't':

  336. 						c = '\t';

  337. 						break;

  338. 					case 'v':

  339. 						c = '\v';

  340. 						break;

  341. 						/* \xHH and \0ooo would come here */

  342. 				}

  343. 				escape = false;

  344. 				write(1, &c, 1);

  345. 			} else {

  346. 				if (c == '\\') {

  347. 					escape = true;

  348. 				} else {

  349. 					write(1, &c, 1);

  350. 				}

  351. 			}

  352. 			++*argv;

  353. 		}

  354. 		c = argv[1] ? ' ' : '\n';

  355. 		write(1, &c, 1);

  356. 		++argv;

  357. 	}

  358. }

  359. 

  360. /* unescapes src into dst (may be the same), returns strlen(dst) */

  361. size_t echo_unescape(char *dst, const char *src) {

  362. 	bool escape;

  363. 	char c;

  364. 	size_t n;

  365. 	

  366. 	n = 0;

  367. 	escape = false;

  368. 	while (*src) {

  369. 		c = *src;

  370. 		if (escape) {

  371. 			switch (c) {

  372. 				case 'a':

  373. 					c = '\a';

  374. 					break;

  375. 				case 'b':

  376. 					c = '\b';

  377. 					break;

  378. 				case 'f':

  379. 					c = '\f';

  380. 					break;

  381. 				case 'n':

  382. 					c = '\n';

  383. 					break;

  384. 				case 'r':

  385. 					c = '\r';

  386. 					break;

  387. 				case 't':

  388. 					c = '\t';

  389. 					break;

  390. 				case 'v':

  391. 					c = '\v';

  392. 					break;

  393. 				/* \xHH and \0ooo would come here */

  394. 			}

  395. 			escape = false;

  396. 			*dst++ = c;

  397. 			++n;

  398. 		} else {

  399. 			if (c == '\\') {

  400. 				escape = true;

  401. 			} else {

  402. 				*dst++ = c;

  403. 				++n;

  404. 			}

  405. 		}

  406. 		++src;

  407. 	}

  408. 	*dst = '\0';

  409. 

  410. 	return n;

  411. }

  412. 

  413. int main(int argc, char **argv) {

  414. 	int devnull;

  415. 

  416. 	devnull = open("/dev/null", O_WRONLY, 0644);

  417. 	if (devnull < 0) {

  418. 		abort();

  419. 	}

  420. 	dup2(1, 2);

  421. 	dup2(devnull, 1);

  422. 	test_init(argc-1, argv+1);

  423. 

  424. 	fprintf(stderr, "echo_null     (%d runs): %" PRId64 "us\n", NITER, bench(test_null, NITER));

  425. 	fprintf(stderr, "echo_buf      (%d runs): %" PRId64 "us\n", NITER, bench(test_buf, NITER));

  426. 	fprintf(stderr, "echo_inplace  (%d runs): %" PRId64 "us\n", NITER, bench(test_inplace, NITER));

  427. 	fprintf(stderr, "echo_finplace (%d runs): %" PRId64 "us\n", NITER, bench(test_finplace, NITER));

  428. 	fprintf(stderr, "echo_putchar  (%d runs): %" PRId64 "us\n", NITER, bench(test_putchar, NITER));

  429. 	fprintf(stderr, "echo_putcharu (%d runs): %" PRId64 "us\n", NITER, bench(test_putcharu, NITER));

  430. 	fprintf(stderr, "echo_write    (%d runs): %" PRId64 "us\n", NITER, bench(test_write, NITER));

  431. 

  432. 	test_free();

  433. 	close(devnull);

  434. 

  435. 	return 0;

  436. }

    437.