开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 代理服务器 > 查看源码
membanger.c
资源名称：squid-2.2.devel3-src.tar.gz　[点击查看]
上传用户：liugui
上传日期：2007-01-04
资源大小：822k
文件大小：6k
源码类别：

代理服务器

开发平台：

Unix_Linux

membanger.c：源码内容
  1. #include <unistd.h>
  2. #include <stdlib.h>
  3. #include <stdio.h>
  4. #include <sys/types.h>
  5. #include <ctype.h>
  6. #include <sys/time.h>
  7. #include <strings.h>
  8. #include <sys/time.h>
  9. #include <sys/resource.h>
  11. #include "hash.h"
  13. static hash_table *mem_table = NULL;
  14. static hash_link *mem_entry;
  15. struct rusage myusage;
  17. #ifdef WITH_LIB
  18. #include "Mem.h"
  19. #include <assert.h>
  20. extern void sizeToPoolInit();
  21. extern MemPool *sizeToPool(size_t size);
  22. #endif
  23. extern char *malloc_options;
  24. void my_free(char *, int, void *);
  26. FILE *fp;
  27. char *fn;
  28. int initsiz;
  29. int maxsiz;
  30. int minchunk;
  31. HASHCMP ptrcmp;
  32. char mbuf[256];
  33. char abuf[32];
  34. char *p;
  36. int size;
  37. void *addr;
  38. int amt;
  40. int i;
  41. int a;
  42. int run_stats=0;
  43. void *my_xmalloc(size_t);
  44. void *my_xcalloc(int, size_t);
  45. int my_xfree(void *);
  47. #define xmalloc my_xmalloc
  48. #define xcalloc my_xcalloc
  49. #define xfree my_xfree
  51. int *size2id_array[2];
  52. int size2id_len=0;
  53. int size2id_alloc=0;
  55. typedef struct {
  56. char orig_ptr[32];
  57. void *my_ptr;
  58. #ifdef WITH_LIB
  59. MemPool *pool;
  60. #endif
  61. int size;
  62. } memitem;
  64. struct {
  65. int mallocs,frees,callocs,reallocs;
  66. } mstat;
  68. memitem *mi;
  69. void size2id(size_t, memitem *);
  70. void badformat();
  71. void init_stats(), print_stats();
  72. void my_hash_insert(hash_table *h, const char *k, memitem *item);
  73. static void *xmemAlloc(memitem *item);
  74. static void xmemFree(memitem *item);
  76. int 
  77. ptrcmp(const void *a,const void *b) 
  78. {
  79. return (strcmp(a,b));
  80. }
  82. main(int argc,char **argv)
  83. {
  84.     char c;
  85.     extern char *optarg; 
  86.     malloc_options = "A";
  87.     a=0;
  88.     while ((c = getopt(argc, argv, "f:i:M:l:m:r:N")) != -1) {
  89.       switch (c) {
  90. case 'N':
  91.    mem_pools_on=0;
  92.    break;
  93. case 'r':
  94.   run_stats=atoi(optarg);
  95.   break;
  96. case 'f':
  97.   fn=strdup(optarg);
  98.   fp=fopen(fn,"r");
  99.   break;
  100. case 'i':
  101.   initsiz=atoi(optarg);
  102.   break;
  103. case 'l':
  104.   mem_max_size = atoi(optarg)*1024*1024;
  105.   break;
  106. case 'M':
  107.   maxsiz=atoi(optarg);
  108.   break;
  109. case 'm':
  110.   minchunk=atoi(optarg);
  111.   break;
  112. default:
  113.      fprintf(stderr,
  114. "Usage: %s -f file -M maxsiz -i initsiz -m minchunk",argv[0]);
  115.   exit(1);
  116.       }
  118.     }
  119.     if (!fp) {
  120. fprintf(stderr,
  121. "%s pummels %sn%s . o O ( You't supply a valid tracefile.)n",
  122. argv[0], getenv("USER"), argv[0]);
  123. exit(1);
  124.     }
  125. #ifdef WITH_LIB
  126.     sizeToPoolInit();
  127. #endif
  128.     mem_table = hash_create(ptrcmp, 229, hash4);         /* small hash table */
  129.     init_stats();
  130.     while (fgets(mbuf, 256, fp)!=NULL) {
  131. if (run_stats>0 && (++a)%run_stats==0) print_stats();
  132. p=NULL;
  133. switch(mbuf[0]) {
  134. case 'm': /* malloc */
  135.    p=strtok(&mbuf[2],":");
  136.    if (!p) badformat();
  137.    size=atoi(p);
  138.    p=strtok(NULL,"n");
  139.    if (!p) badformat();
  140.    mi=malloc(sizeof(memitem)); 
  141.    strcpy(mi->orig_ptr,p);
  142.    mi->size=size;
  143.    size2id(size,mi);
  144.    mi->my_ptr = xmemAlloc(mi); /* (void *)xmalloc(size); */
  145.    assert(mi->my_ptr);
  146.    my_hash_insert(mem_table, mi->orig_ptr, mi);
  147.    mstat.mallocs++;
  148.    break;
  149. case 'c': /* calloc */
  150.    p=strtok(&mbuf[2],":");
  151.    if (!p) badformat();
  152.    amt=atoi(p);
  153.    p=strtok(NULL,":");
  154.    if (!p) badformat();
  155.    size=atoi(p);
  156.    p=strtok(NULL,"n");
  157.    if (!p) badformat();
  158.            mi=malloc(sizeof(memitem));
  159.    strcpy(mi->orig_ptr,p);
  160.    size2id(size,mi);
  161.            mi->size=amt*size;
  162.            mi->my_ptr= xmemAlloc(mi); /*(void *)xmalloc(amt*size);*/
  163.    assert(mi->my_ptr);
  164.    my_hash_insert(mem_table, mi->orig_ptr, mi);
  165.    mstat.callocs++;
  166.    break;
  167. case 'r':
  168.            p=strtok(&mbuf[2],":");
  169.    if (!p) badformat();
  170.    strcpy(abuf,p);
  171.            p=strtok(NULL,":");
  172.    if (!p) badformat();
  173.    mem_entry=hash_lookup(mem_table, p);
  174.            if (mem_entry==NULL) {
  175.                 fprintf(stderr,"invalid realloc (%s)!n",p);
  176. break;
  177.            }
  178.    mi=(memitem *)(mem_entry->item);
  179.    assert(mi->pool);
  180.    assert(mi->my_ptr);
  181.    xmemFree(mi); /* xfree(mi->my_ptr); */
  182.    size2id(atoi(p),mi);   /* we don't need it here I guess? */
  183.            strcpy(mi->orig_ptr,abuf);
  184.    p=strtok(NULL,"n");
  185.    if (!p) badformat();
  186.    mi->my_ptr= xmemAlloc(mi); /* (char *)xmalloc(atoi(p)); */
  187.    assert(mi->my_ptr);
  188.    mstat.reallocs++;
  189.    break;
  190. case 'f':
  191.    p=strtok(&mbuf[2],"n");
  192.    mem_entry=hash_lookup(mem_table, p);
  193.    if (mem_entry==NULL) {
  194. if (p[0]!='0')
  195. fprintf(stderr,"invalid free (%s) at line %d!n",p,a);
  196. break;
  197.    }
  198.    mi=(memitem *)(mem_entry->item);
  199.    assert(mi->pool);
  200.    assert(mi->my_ptr);
  201.    xmemFree(mi); /* xfree(mi->my_ptr); */ 
  202.    hash_unlink(mem_table, mem_entry, 1);
  203.    free(mi);
  204.    mstat.frees++;
  205.    break;
  206. default:
  207. fprintf(stderr,"%s pummels %s.bad.formatn", argv[0],fn);
  208. exit(1);
  209. }
  211.     }
  212.     fclose(fp);
  213.     print_stats();
  214. }
  216. void *
  217. my_xmalloc(size_t a)
  218. {
  219. return NULL;
  220. }
  222. void *
  223. my_xcalloc(int a, size_t b)
  224. {
  225. return NULL;
  226. }
  228. int
  229. my_xfree(void *p)
  230. {
  231. return 0;
  232. }
  233. void
  234. init_stats()
  235. {
  237. }
  239. void
  240. print_stats()
  241. {
  242. #ifdef WITH_LIB
  243.         memReport(stdout); 
  244. #endif
  245. getrusage(RUSAGE_SELF, &myusage);
  246. printf("m/c/f/r=%d/%d/%d/%dn",mstat.mallocs,mstat.callocs,
  247. mstat.frees, mstat.reallocs);
  248. #if 0
  249. printf("types                 : %dn",size2id_len);
  250. #endif
  251. printf("user time used        : %d.%dn", (int)myusage.ru_utime.tv_sec,
  252. (int)myusage.ru_utime.tv_usec);
  253. printf("system time used      : %d.%dn", (int)myusage.ru_stime.tv_sec,
  254.                                                 (int)myusage.ru_stime.tv_usec);
  255. printf("max resident set size : %dn",(int)myusage.ru_maxrss);
  256. printf("page faults           : %dn", (int)myusage.ru_majflt);
  257. }
  259. void
  260. size2id(size_t sz,memitem *mi)
  261. {
  262. #ifdef WITH_LIB
  263. mi->pool = sizeToPool(sz);
  264. assert(mi->pool);
  265. #endif
  266. return;
  267. }
  269. void
  270. badformat()
  271. {
  272.     fprintf(stderr,"pummel.bad.formatn");
  273.     exit(1);
  274. }
  276. /* unused code, saved for parts */
  277. const char *
  278. make_nam(int id, int size)
  279. {
  280.     const char *buf = malloc(30); /* argh */
  281.     sprintf((char *)buf, "pl:%d/%d", id, size);
  282.     return buf;
  283. }
  285. void
  286. my_hash_insert(hash_table *h, const char *k, memitem *item)
  287. {
  288. memitem *l;
  289. assert( item->pool);
  290. assert( item->my_ptr);
  291. hash_insert(h,k,item);
  292. }
  294. static void *
  295. xmemAlloc(memitem *item)
  296. {
  297.     extern MemPool *StringPool;
  298.     assert(item && item->pool);
  299.     if (StringPool == item->pool)
  300. return memStringAlloc(item->pool, item->size);
  301.     else
  302. return memAlloc(item->pool);
  303. }
  305. static void
  306. xmemFree(memitem *item)
  307. {
  308.     extern MemPool *StringPool;
  309.     assert(item && item->pool);
  310.     if (StringPool == item->pool)
  311.         return memStringFree(item->pool, item->my_ptr, item->size);
  312.     else
  313.         return memFree(item->pool, item->my_ptr);
  314. }
  316. void my_free(char *file, int line, void *ptr)
  317. {
  318. #if 0
  319. fprintf(stderr,"{%s:%d:%p",file,line,ptr);
  320. #endif
  321. free(ptr);
  322. #if 0 
  323. fprintf(stderr,"}n");
  324. #endif
  325. }