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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 通讯编程 > 查看源码
pagepool.cc
资源名称：ns-allinone-2.33.tar.gz　[点击查看]
上传用户：rrhhcc
上传日期：2015-12-11
资源大小：54129k
文件大小：31k
源码类别：

通讯编程

开发平台：

Visual C++

pagepool.cc：源码内容
  1. /*
  2.  * Copyright (c) Xerox Corporation 1998. All rights reserved.
  3.  *
  4.  * This program is free software; you can redistribute it and/or modify it
  5.  * under the terms of the GNU General Public License as published by the
  6.  * Free Software Foundation; either version 2 of the License, or (at your
  7.  * option) any later version.
  8.  *
  9.  * This program is distributed in the hope that it will be useful, but
  10.  * WITHOUT ANY WARRANTY; without even the implied warranty of
  11.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12.  * General Public License for more details.
  13.  *
  14.  * You should have received a copy of the GNU General Public License along
  15.  * with this program; if not, write to the Free Software Foundation, Inc.,
  16.  * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  17.  *
  18.  * Linking this file statically or dynamically with other modules is making
  19.  * a combined work based on this file.  Thus, the terms and conditions of
  20.  * the GNU General Public License cover the whole combination.
  21.  *
  22.  * In addition, as a special exception, the copyright holders of this file
  23.  * give you permission to combine this file with free software programs or
  24.  * libraries that are released under the GNU LGPL and with code included in
  25.  * the standard release of ns-2 under the Apache 2.0 license or under
  26.  * otherwise-compatible licenses with advertising requirements (or modified
  27.  * versions of such code, with unchanged license).  You may copy and
  28.  * distribute such a system following the terms of the GNU GPL for this
  29.  * file and the licenses of the other code concerned, provided that you
  30.  * include the source code of that other code when and as the GNU GPL
  31.  * requires distribution of source code.
  32.  *
  33.  * Note that people who make modified versions of this file are not
  34.  * obligated to grant this special exception for their modified versions;
  35.  * it is their choice whether to do so.  The GNU General Public License
  36.  * gives permission to release a modified version without this exception;
  37.  * this exception also makes it possible to release a modified version
  38.  * which carries forward this exception.
  39.  *
  40.  * $Header: /cvsroot/nsnam/ns-2/webcache/pagepool.cc,v 1.17 2006/02/21 15:20:20 mahrenho Exp $
  41.  */
  43. #include <stdlib.h>
  44. #include <sys/types.h>
  45. #include <fcntl.h>
  46. #ifdef WIN32
  47. #include <windows.h>
  48. #include <io.h>
  49. #else 
  50. #include <unistd.h>
  51. #include <sys/file.h>
  52. #endif
  53. #include <sys/stat.h>
  55. #include <stdio.h>
  56. #include <limits.h>
  57. #include <ctype.h>
  59. extern "C" {
  60. #include <otcl.h>
  61. }
  62. #include "pagepool.h"
  63. #include "http.h"
  65. // Static/global variables
  66. int ClientPage::PUSHALL_ = 0; // Initialized to selective push
  68. void ServerPage::set_mtime(int *mt, int n)
  69. {
  70. if (mtime_ != NULL) 
  71. delete []mtime_;
  72. mtime_ = new int[n];
  73. memcpy(mtime_, mt, sizeof(int)*n);
  74. }
  76. ClientPage::ClientPage(const char *n, int s, double mt, double et, double a) :
  77. Page(s), age_(a), mtime_(mt), etime_(et), 
  78. status_(HTTP_VALID_PAGE), counter_(0), 
  79. mpushTime_(0)
  80. {
  81. // Parse name to get server and page id
  82. char *buf = new char[strlen(n) + 1];
  83. strcpy(buf, n);
  84. char *tmp = strtok(buf, ":");
  85. server_ = (HttpApp*)TclObject::lookup(tmp);
  86. if (server_ == NULL) {
  87. fprintf(stderr, "Non-exitent server name for page %s", n);
  88. abort();
  89. }
  90. tmp = strtok(NULL, ":");
  91. id_ = atol(tmp);
  92. delete []buf;
  93. }
  95. void ClientPage::print_name(char* name, PageID& id)
  96. {
  97. sprintf(name, "%s:%-d", id.s_->name(), id.id_);
  98. }
  100. void ClientPage::split_name(const char* name, PageID& id)
  101. {
  102. char *buf = new char[strlen(name)+1];
  103. strcpy(buf, name);
  104. char *tmp = strtok(buf, ":");
  105. id.s_ = (HttpApp*)TclObject::lookup(tmp);
  106. if (id.s_ == NULL) {
  107. fprintf(stderr, "Non-exitent server name for page %sn", name);
  108. abort();
  109. }
  110. tmp = strtok(NULL, ":");
  111. id.id_ = atol(tmp);
  112. delete []buf;
  113. }
  115. void ClientPage::print_info(char *buf)
  116. {
  117. sprintf(buf, "size %d modtime %.17g time %.17g age %.17g",
  118. size(), mtime(), etime(), age());
  119. if (is_uncacheable())
  120. strcat(buf, " noc 1");
  121. }
  123. void ClientPage::name(char* buf) 
  124. {
  125. sprintf(buf, "%s:%d", server_->name(), id());
  126. }
  129. static class PagePoolClass : public TclClass {
  130. public:
  131.         PagePoolClass() : TclClass("PagePool") {}
  132.         TclObject* create(int, const char*const*) {
  133. return (new PagePool());
  134. }
  135. } class_pagepool_agent;
  137. int PagePool::command(int argc, const char*const* argv)
  138. {
  139. if (argc == 2) {
  140. // XXX Should be static class variables... 
  141. if (strcmp(argv[1], "set-allpush") == 0) {
  142. ClientPage::PUSHALL_ = 1;
  143. return (TCL_OK);
  144. }
  145. if (strcmp(argv[1], "set-selpush") == 0) {
  146. ClientPage::PUSHALL_ = 0;
  147. return (TCL_OK);
  148. }
  149. }
  150. return TclObject::command(argc, argv);
  151. }
  154. // TracePagePool
  155. // Used for Worrell's filtered server traces only. For handling general 
  156. // web server traces and proxy traces, have a look at ProxyTracePagePool below.
  157. //
  158. // Load a trace statistics file, and randomly generate requests and 
  159. // page lifetimes from the trace.
  160. //
  161. // Trace statistics file format:
  162. // <URL> <size> {<modification time>}
  164. static class TracePagePoolClass : public TclClass {
  165. public:
  166.         TracePagePoolClass() : TclClass("PagePool/Trace") {}
  167.         TclObject* create(int argc, const char*const* argv) {
  168. if (argc >= 5)
  169. return (new TracePagePool(argv[4]));
  170. return 0;
  171. }
  172. } class_tracepagepool_agent;
  174. TracePagePool::TracePagePool(const char *fn) : 
  175. PagePool(), ranvar_(0)
  176. {
  177. FILE *fp = fopen(fn, "r");
  178. if (fp == NULL) {
  179. fprintf(stderr, 
  180. "TracePagePool: couldn't open trace file %sn", fn);
  181. abort(); // What else can we do?
  182. }
  184. namemap_ = new Tcl_HashTable;
  185. Tcl_InitHashTable(namemap_, TCL_STRING_KEYS);
  186. idmap_ = new Tcl_HashTable;
  187. Tcl_InitHashTable(idmap_, TCL_ONE_WORD_KEYS);
  189. while (load_page(fp));
  190. change_time();
  191. }
  193. TracePagePool::~TracePagePool()
  194. {
  195. if (namemap_ != NULL) {
  196. Tcl_DeleteHashTable(namemap_);
  197. delete namemap_;
  198. }
  199. if (idmap_ != NULL) {
  200. Tcl_DeleteHashTable(idmap_);
  201. delete idmap_;
  202. }
  203. }
  205. void TracePagePool::change_time()
  206. {
  207. Tcl_HashEntry *he;
  208. Tcl_HashSearch hs;
  209. ServerPage *pg;
  210. int i, j;
  212. for (i = 0, he = Tcl_FirstHashEntry(idmap_, &hs);
  213.      he != NULL;
  214.      he = Tcl_NextHashEntry(&hs), i++) {
  215. pg = (ServerPage *) Tcl_GetHashValue(he);
  216. for (j = 0; j < pg->num_mtime(); j++) 
  217. pg->mtime(j) -= (int)start_time_;
  218. }
  219. end_time_ -= start_time_;
  220. start_time_ = 0;
  221. duration_ = (int)end_time_;
  222. }
  224. ServerPage* TracePagePool::load_page(FILE *fp)
  225. {
  226. static char buf[TRACEPAGEPOOL_MAXBUF];
  227. char *delim = " tn";
  228. char *tmp1, *tmp2;
  229. ServerPage *pg;
  231. // XXX Use internal variables of struct Page
  232. if (!fgets(buf, TRACEPAGEPOOL_MAXBUF, fp))
  233. return NULL;
  235. // URL
  236. tmp1 = strtok(buf, delim);
  237. // Size
  238. tmp2 = strtok(NULL, delim);
  239. pg = new ServerPage(atoi(tmp2), num_pages_++);
  241. if (add_page(tmp1, pg)) {
  242. delete pg;
  243. return NULL;
  244. }
  246. // Modtimes, assuming they are in ascending time order
  247. int num = 0;
  248. int *nmd = new int[5];
  249. while ((tmp1 = strtok(NULL, delim)) != NULL) {
  250. if (num >= 5) {
  251. int *tt = new int[num+5];
  252. memcpy(tt, nmd, sizeof(int)*num);
  253. delete []nmd;
  254. nmd = tt;
  255. }
  256. nmd[num] = atoi(tmp1);
  257. if (nmd[num] < start_time_)
  258. start_time_ = nmd[num];
  259. if (nmd[num] > end_time_)
  260. end_time_ = nmd[num];
  261. num++;
  262. }
  263. pg->num_mtime() = num;
  264. pg->set_mtime(nmd, num);
  265. delete []nmd;
  266. return pg;
  267. }
  269. int TracePagePool::add_page(const char* name, ServerPage *pg)
  270. {
  271. int newEntry = 1;
  272. Tcl_HashEntry *he = Tcl_CreateHashEntry(namemap_, 
  273. (const char *)name,
  274. &newEntry);
  275. if (he == NULL)
  276. return -1;
  277. if (newEntry)
  278. Tcl_SetHashValue(he, (ClientData)pg);
  279. else 
  280. fprintf(stderr, "TracePagePool: Duplicate entry %sn", 
  281. name);
  283. long key = pg->id();
  284. Tcl_HashEntry *hf = 
  285. Tcl_CreateHashEntry(idmap_, (const char *)key, &newEntry);
  286. if (hf == NULL) {
  287. Tcl_DeleteHashEntry(he);
  288. return -1;
  289. }
  290. if (newEntry)
  291. Tcl_SetHashValue(hf, (ClientData)pg);
  292. else 
  293. fprintf(stderr, "TracePagePool: Duplicate entry %dn", 
  294. pg->id());
  296. return 0;
  297. }
  299. ServerPage* TracePagePool::get_page(int id)
  300. {
  301. if ((id < 0) || (id >= num_pages_))
  302. return NULL;
  303. long key = id;
  304. Tcl_HashEntry *he = Tcl_FindHashEntry(idmap_, (const char *)key);
  305. if (he == NULL)
  306. return NULL;
  307. return (ServerPage *)Tcl_GetHashValue(he);
  308. }
  310. int TracePagePool::command(int argc, const char *const* argv)
  311. {
  312. Tcl &tcl = Tcl::instance();
  314. if (argc == 2) {
  315. if (strcmp(argv[1], "get-poolsize") == 0) {
  316. /* 
  317.  * <pgpool> get-poolsize
  318.  * Get the number of pages currently in pool
  319.  */
  320. tcl.resultf("%d", num_pages_);
  321. return TCL_OK;
  322. } else if (strcmp(argv[1], "get-start-time") == 0) {
  323. tcl.resultf("%.17g", start_time_);
  324. return TCL_OK;
  325. } else if (strcmp(argv[1], "get-duration") == 0) {
  326. tcl.resultf("%d", duration_);
  327. return TCL_OK;
  328. }
  329. } else if (argc == 3) {
  330. if (strcmp(argv[1], "gen-pageid") == 0) {
  331. /* 
  332.  * <pgpool> gen-pageid <client_id>
  333.  * Randomly generate a page id from page pool
  334.  */
  335. double tmp = ranvar_ ? ranvar_->value() : 
  336. Random::uniform();
  337. // tmp should be in [0, num_pages_-1]
  338. tmp = (tmp < 0) ? 0 : (tmp >= num_pages_) ? 
  339. (num_pages_-1):tmp;
  340. if ((int)tmp >= num_pages_) abort();
  341. tcl.resultf("%d", (int)tmp);
  342. return TCL_OK;
  343. } else if (strcmp(argv[1], "gen-size") == 0) {
  344. /*
  345.  * <pgpool> gen-size <pageid>
  346.  */
  347. int id = atoi(argv[2]);
  348. ServerPage *pg = get_page(id);
  349. if (pg == NULL) {
  350. tcl.add_errorf("TracePagePool %s: page %d doesn't exists.n",
  351.        name_, id);
  352. return TCL_ERROR;
  353. }
  354. tcl.resultf("%d", pg->size());
  355. return TCL_OK;
  356. } else if (strcmp(argv[1], "ranvar") == 0) {
  357. /* 
  358.  * <pgpool> ranvar <ranvar> 
  359.  * Set a random var which is used to randomly pick 
  360.  * a page from the page pool.
  361.  */
  362. ranvar_ = (RandomVariable *)TclObject::lookup(argv[2]);
  363. return TCL_OK;
  364. } else if (strcmp(argv[1], "set-start-time") == 0) {
  365. double st = strtod(argv[2], NULL);
  366. start_time_ = st;
  367. end_time_ += st;
  368. } else if (strcmp(argv[1], "gen-init-modtime") == 0) {
  369. tcl.resultf("%.17g", Scheduler::instance().clock());
  370. return TCL_OK;
  371. }
  372. } else {
  373. if (strcmp(argv[1], "gen-modtime") == 0) {
  374. /* 
  375.  * <pgpool> get-modtime <pageid> <modtime>
  376.  * 
  377.  * Return next modtime that is larger than modtime
  378.  * To retrieve the first modtime (creation time), set 
  379.  * <modtime> to -1 in the request.
  380.  */
  381. int id = atoi(argv[2]);
  382. double mt = strtod(argv[3], NULL);
  383. ServerPage *pg = get_page(id);
  384. if (pg == NULL) {
  385. tcl.add_errorf("TracePagePool %s: page %d doesn't exists.n",
  386.        name_, id);
  387. return TCL_ERROR;
  388. }
  389. for (int i = 0; i < pg->num_mtime(); i++) 
  390. if (pg->mtime(i) > mt) {
  391. tcl.resultf("%.17g", 
  392.     pg->mtime(i)+start_time_);
  393. return TCL_OK;
  394. }
  395. // When get to the last modtime, return -1
  396. tcl.resultf("%d", INT_MAX);
  397. return TCL_OK;
  398. }
  399. }
  400. return PagePool::command(argc, argv);
  401. }
  405. static class MathPagePoolClass : public TclClass {
  406. public:
  407.         MathPagePoolClass() : TclClass("PagePool/Math") {}
  408.         TclObject* create(int, const char*const*) {
  409. return (new MathPagePool());
  410. }
  411. } class_mathpagepool_agent;
  413. // Use 3 ranvars to generate requests, mod times and page size
  415. int MathPagePool::command(int argc, const char *const* argv)
  416. {
  417. Tcl& tcl = Tcl::instance();
  419. // Keep the same tcl interface as PagePool/Trace
  420. if (argc == 2) {
  421. if (strcmp(argv[1], "get-poolsize") == 0) { 
  422. tcl.result("1");
  423. return TCL_OK;
  424. } else if (strcmp(argv[1], "get-start-time") == 0) {
  425. tcl.resultf("%.17g", start_time_);
  426. return TCL_OK;
  427. } else if (strcmp(argv[1], "get-duration") == 0) {
  428. tcl.resultf("%d", duration_);
  429. return TCL_OK;
  430. }
  431. } else if (argc == 3) {
  432. if (strcmp(argv[1], "gen-pageid") == 0) {
  433. // Single page
  434. tcl.result("0");
  435. return TCL_OK;
  436. } else if (strcmp(argv[1], "gen-size") == 0) {
  437. if (rvSize_ == 0) {
  438. tcl.add_errorf("%s: no page size generator", 
  439.        name_);
  440. return TCL_ERROR;
  441. }
  442. int size = (int) rvSize_->value();
  443. if (size == 0)
  444. // XXX do not allow page size 0, because TcpApp
  445. // doesn't behave correctly when sending 0 byte
  446. size = 1;
  447. tcl.resultf("%d", size);
  448. return TCL_OK;
  449. } else if (strcmp(argv[1], "ranvar-size") == 0) {
  450. rvSize_ = (RandomVariable*)TclObject::lookup(argv[2]);
  451. return TCL_OK;
  452. } else if (strcmp(argv[1], "ranvar-age") == 0) {
  453. rvAge_ = (RandomVariable*)TclObject::lookup(argv[2]);
  454. return TCL_OK;
  455. } else if (strcmp(argv[1], "set-start-time") == 0) {
  456. double st = strtod(argv[2], NULL);
  457. start_time_ = st;
  458. end_time_ += st;
  459. return TCL_OK;
  460. } else if (strcmp(argv[1], "gen-init-modtime") == 0) {
  461. tcl.resultf("%.17g", Scheduler::instance().clock());
  462. return TCL_OK;
  463. }
  464. } else {
  465. if (strcmp(argv[1], "gen-modtime") == 0) {
  466. if (rvAge_ == 0) {
  467. tcl.add_errorf("%s: no page age generator", 
  468.        name_);
  469. return TCL_ERROR;
  470. }
  471. double mt = strtod(argv[3], NULL);
  472. tcl.resultf("%.17g", mt + rvAge_->value());
  473. return TCL_OK;
  474. }
  475. }
  477. return PagePool::command(argc, argv);
  478. }
  481. // Assume one main page, which changes often, and multiple component pages
  482. static class CompMathPagePoolClass : public TclClass {
  483. public:
  484.         CompMathPagePoolClass() : TclClass("PagePool/CompMath") {}
  485.         TclObject* create(int, const char*const*) {
  486. return (new CompMathPagePool());
  487. }
  488. } class_compmathpagepool_agent;
  491. CompMathPagePool::CompMathPagePool()
  492. {
  493. bind("num_pages_", &num_pages_);
  494. bind("main_size_", &main_size_);
  495. bind("comp_size_", &comp_size_);
  496. }
  498. int CompMathPagePool::command(int argc, const char *const* argv)
  499. {
  500. Tcl& tcl = Tcl::instance();
  502. // Keep the same tcl interface as PagePool/Trace
  503. if (argc == 2) {
  504. if (strcmp(argv[1], "get-poolsize") == 0) { 
  505. tcl.result("1");
  506. return TCL_OK;
  507. } else if (strcmp(argv[1], "get-start-time") == 0) {
  508. tcl.resultf("%.17g", start_time_);
  509. return TCL_OK;
  510. } else if (strcmp(argv[1], "get-duration") == 0) {
  511. tcl.resultf("%d", duration_);
  512. return TCL_OK;
  513. }
  515. } else if (argc == 3) {
  516. if (strcmp(argv[1], "gen-pageid") == 0) {
  517. // Main pageid, never return id of component pages
  518. tcl.result("0");
  519. return TCL_OK;
  520. } else if (strcmp(argv[1], "gen-size") == 0) {
  521. int id = atoi(argv[2]);
  522. if (id == 0) 
  523. tcl.resultf("%d", main_size_);
  524. else 
  525. tcl.resultf("%d", comp_size_);
  526. return TCL_OK;
  527. } else if (strcmp(argv[1], "gen-obj-size") == 0) {
  528. tcl.resultf("%d", comp_size_);
  529. return (TCL_OK);
  530. } else if (strcmp(argv[1], "get-next-objs") == 0) {
  531. PageID id;
  532. ClientPage::split_name(argv[2], id);
  533. // If we want simultaneous requests of multiple
  534. // objects, return a list; otherwise return a single
  535. // pageid. 
  536. for (int i = id.id_+1; i < num_pages_; i++) {
  537. tcl.resultf("%s %s:%d", tcl.result(), 
  538.     id.s_->name(), i);
  539. }
  540. return TCL_OK;
  541. } else if (strcmp(argv[1], "ranvar-main-age") == 0) {
  542. rvMainAge_ = 
  543. (RandomVariable*)TclObject::lookup(argv[2]);
  544. return TCL_OK;
  545. } else if (strcmp(argv[1], "ranvar-obj-age") == 0) {
  546. rvCompAge_ =
  547. (RandomVariable*)TclObject::lookup(argv[2]);
  548. return TCL_OK;
  549. } else if (strcmp(argv[1], "set-start-time") == 0) {
  550. double st = strtod(argv[2], NULL);
  551. start_time_ = st;
  552. end_time_ += st;
  553. return TCL_OK;
  554. } else if (strcmp(argv[1], "gen-init-modtime") == 0) {
  555. tcl.resultf("%.17g", Scheduler::instance().clock());
  556. return TCL_OK;
  557. } else if (strcmp(argv[1], "is-mainpage") == 0) {
  558. // Tell if the given page is a main page or an 
  559. // embedded object. 
  560. // XXX Here because we have only one page, so only 
  561. // page id 0 is the main page. If we have multiple 
  562. // pages, we need something else to do this.
  563. PageID t1;
  564. ClientPage::split_name(argv[2], t1);
  565. if (t1.id_ == 0)
  566. tcl.result("1");
  567. else 
  568. tcl.result("0");
  569. return TCL_OK;
  570. } else if (strcmp(argv[1], "get-mainpage") == 0) {
  571. // Get the main page of an embedded object
  572. // XXX Should maintain a mapping between embedded
  573. // objects and main pages. It can be an algorithmic
  574. // one, e.g., using page id intervals. It's simple 
  575. // here because we have only one page.
  576. PageID t1;
  577. ClientPage::split_name(argv[2], t1);
  578. tcl.resultf("%s:0", t1.s_->name());
  579. return TCL_OK;
  580. } else if (strcmp(argv[1], "get-obj-num") == 0) {
  581. // Returns the number of embedded objects of the page
  582. // given in argv[1]. Here because we have only one 
  583. // page, we return a fixed value.
  584. tcl.resultf("%d", num_pages_-1);
  585. return TCL_OK;
  586. }
  588. } else {
  589. // argc > 3
  590. if (strcmp(argv[1], "gen-modtime") == 0) {
  591. int id = atoi(argv[2]);
  592. if (id == 0) {
  593. if (rvMainAge_ == 0) {
  594.   tcl.add_errorf("%s: no page age generator", 
  595.  name_);
  596. return TCL_ERROR;
  597. }
  598. double mt = strtod(argv[3], NULL);
  599. tcl.resultf("%.17g", mt + rvMainAge_->value());
  600. } else {
  601. if (rvCompAge_ == 0) {
  602.    tcl.add_errorf("%s: no page age generator", 
  603.   name_);
  604.    return TCL_ERROR;
  605. }
  606. double mt = atoi(argv[3]);
  607. tcl.resultf("%.17g", mt + rvCompAge_->value());
  608. }
  609. return TCL_OK;
  610. } else if (strcmp(argv[1], "gen-obj-modtime") == 0) {
  611. if (rvCompAge_ == 0) {
  612. tcl.add_errorf("%s: no page age generator", 
  613.        name_);
  614. return TCL_ERROR;
  615. }
  616. double mt = atoi(argv[3]);
  617. tcl.resultf("%.17g", mt + rvCompAge_->value());
  618. return TCL_OK;
  619. }
  620. }
  622. return PagePool::command(argc, argv);
  623. }
  626. static class ClientPagePoolClass : public TclClass {
  627. public:
  628.         ClientPagePoolClass() : TclClass("PagePool/Client") {}
  629.         TclObject* create(int, const char*const*) {
  630. return (new ClientPagePool());
  631. }
  632. } class_clientpagepool_agent;
  634. ClientPagePool::ClientPagePool()
  635. {
  636. namemap_ = new Tcl_HashTable;
  637. Tcl_InitHashTable(namemap_, 2);
  638. }
  640. ClientPagePool::~ClientPagePool()
  641. {
  642. if (namemap_ != NULL) {
  643. Tcl_DeleteHashTable(namemap_);
  644. delete namemap_;
  645. }
  646. }
  648. // In case client/cache/server needs details, e.g., page listing
  649. int ClientPagePool::command(int argc, const char*const* argv)
  650. {
  651. Tcl& tcl = Tcl::instance();
  652. if (argc == 2) {
  653. if (strcmp(argv[1], "list-pages") == 0) {
  654. Tcl_HashEntry *he;
  655. Tcl_HashSearch hs;
  656. char *buf = new char[num_pages_*20];
  657. char *p = buf;
  658. for (he = Tcl_FirstHashEntry(namemap_, &hs); 
  659.      he != NULL;
  660.      he = Tcl_NextHashEntry(&hs)) {
  661. int* t2 = (int*)Tcl_GetHashKey(namemap_, he);
  662. PageID t1(t2);
  663. #ifdef NEED_SUNOS_PROTOS
  664. sprintf(p, "%s:%-d ", t1.s_->name(),t1.id_);
  665. p += strlen(p);
  666. #else
  667. p += sprintf(p,"%s:%-d ",t1.s_->name(),t1.id_);
  668. #endif
  669. }
  670. tcl.resultf("%s", buf);
  671. delete []buf;
  672. return TCL_OK;
  673. }
  674. }
  675. return PagePool::command(argc, argv);
  676. }
  678. ClientPage* ClientPagePool::get_page(const char *name)
  679. {
  680. PageID t1;
  681. ClientPage::split_name(name, t1);
  683. Tcl_HashEntry *he = Tcl_FindHashEntry(namemap_, (const char *)&t1);
  684. if (he == NULL)
  685. return NULL;
  686. return (ClientPage *)Tcl_GetHashValue(he);
  687. }
  689. int ClientPagePool::get_pageinfo(const char *name, char *buf)
  690. {
  691. ClientPage *pg = get_page(name);
  692. if (pg == NULL) 
  693. return -1;
  694. pg->print_info(buf);
  695. return 0;
  696. }
  698. ClientPage* ClientPagePool::enter_page(int argc, const char*const* argv)
  699. {
  700. double mt = -1, et, age = -1, noc = 0;
  701. int size = -1;
  702. for (int i = 3; i < argc; i+=2) {
  703. if (strcmp(argv[i], "modtime") == 0)
  704. mt = strtod(argv[i+1], NULL);
  705. else if (strcmp(argv[i], "size") == 0) 
  706. size = atoi(argv[i+1]);
  707. else if (strcmp(argv[i], "age") == 0)
  708. age = strtod(argv[i+1], NULL);
  709. else if (strcmp(argv[i], "noc") == 0)
  710. // non-cacheable flag
  711. noc = 1;
  712. }
  713. // XXX allow mod time < 0 and age < 0!!
  714. if (size < 0) {
  715. fprintf(stderr, "PagePool %s: wrong information for page %sn",
  716. name_, argv[2]);
  717. return NULL;
  718. }
  719. et = Scheduler::instance().clock();
  720. ClientPage* pg = new ClientPage(argv[2], size, mt, et, age);
  721. if (add_page(pg) < 0) {
  722. delete pg; 
  723. return NULL;
  724. }
  725. if (noc) 
  726. pg->set_uncacheable();
  727. return pg;
  728. }
  730. ClientPage* ClientPagePool::enter_page(const char *name, int size, double mt, 
  731.        double et, double age)
  732. {
  733. ClientPage* pg = new ClientPage(name, size, mt, et, age);
  734. if (add_page(pg) < 0) {
  735. delete pg; 
  736. return NULL;
  737. }
  738. return pg;
  739. }
  741. // XXX We don't need parsing "noc" here because a non-cacheable
  742. // page won't be processed by a cache.
  743. ClientPage* ClientPagePool::enter_metadata(int argc, const char*const* argv)
  744. {
  745. ClientPage *pg = enter_page(argc, argv);
  746. if (pg != NULL)
  747. pg->set_valid_hdr();
  748. return pg;
  749. }
  751. ClientPage* ClientPagePool::enter_metadata(const char *name, int size, 
  752.    double mt, double et, double age)
  753. {
  754. ClientPage *pg = enter_page(name, size, mt, et, age);
  755. if (pg != NULL) 
  756. pg->set_valid_hdr();
  757. return pg;
  758. }
  760. int ClientPagePool::add_page(ClientPage* pg)
  761. {
  762. if (pg == NULL)
  763. return -1;
  765. char buf[HTTP_MAXURLLEN];
  766. pg->name(buf);
  768. PageID t1;
  769. ClientPage::split_name(buf, t1);
  771. int newEntry = 1;
  772. Tcl_HashEntry *he = Tcl_CreateHashEntry(namemap_, 
  773. (const char *)&t1,
  774. &newEntry);
  775. if (he == NULL)
  776. return -1;
  778. // XXX If cache replacement algorithm is added, should change 
  779. // cache size here!!
  780. if (newEntry) {
  781. Tcl_SetHashValue(he, (ClientData)pg);
  782. num_pages_++;
  783.   } else {
  784. // Replace the old one
  785. ClientPage *q = (ClientPage *)Tcl_GetHashValue(he);
  786. // XXX must copy the counter value
  787. pg->counter() = q->counter();
  788. // XXX must copy the mpush values
  789. if (q->is_mpush())
  790. pg->set_mpush(q->mpush_time());
  791. Tcl_SetHashValue(he, (ClientData)pg);
  792. delete q;
  793. }
  794. return 0;
  795. }
  797. int ClientPagePool::remove_page(const char *name)
  798. {
  799. PageID t1;
  800. ClientPage::split_name(name, t1);
  802. // Find out which client we are seeking
  803. Tcl_HashEntry *he = Tcl_FindHashEntry(namemap_, (const char *)&t1);
  804. if (he == NULL)
  805. return -1;
  806. ClientPage *pg = (ClientPage *)Tcl_GetHashValue(he);
  807. Tcl_DeleteHashEntry(he);
  808. delete pg;
  809. num_pages_--;
  810. // XXX If cache replacement algorithm is added, should change
  811. // cache size here!!
  812. return 0;
  813. }
  815. int ClientPagePool::set_mtime(const char *name, double mt)
  816. {
  817. ClientPage *pg = (ClientPage *)get_page(name);
  818. if (pg == NULL) 
  819. return -1;
  820. pg->mtime() = mt;
  821. return 0;
  822. }
  824. int ClientPagePool::get_mtime(const char *name, double& mt)
  825. {
  826. ClientPage *pg = (ClientPage *)get_page(name);
  827. if (pg == NULL) 
  828. return -1;
  829. mt = pg->mtime();
  830. return 0;
  831. }
  833. int ClientPagePool::set_etime(const char *name, double et)
  834. {
  835. ClientPage *pg = (ClientPage *)get_page(name);
  836. if (pg == NULL) 
  837. return -1;
  838. pg->etime() = et;
  839. return 0;
  840. }
  842. int ClientPagePool::get_etime(const char *name, double& et)
  843. {
  844. ClientPage *pg = (ClientPage *)get_page(name);
  845. if (pg == NULL) 
  846. return -1;
  847. et = pg->etime();
  848. return 0;
  849. }
  851. int ClientPagePool::get_size(const char *name, int& size) 
  852. {
  853. ClientPage *pg = (ClientPage *)get_page(name);
  854. if (pg == NULL) 
  855. return -1;
  856. size = pg->size();
  857. return 0;
  858. }
  860. int ClientPagePool::get_age(const char *name, double& age) 
  861. {
  862. ClientPage *pg = (ClientPage *)get_page(name);
  863. if (pg == NULL) 
  864. return -1;
  865. age = pg->age();
  866. return 0;
  867. }
  869. void ClientPagePool::invalidate_server(int sid)
  870. {
  871. Tcl_HashEntry *he;
  872. Tcl_HashSearch hs;
  873. ClientPage *pg;
  874. int i;
  876. for (i = 0, he = Tcl_FirstHashEntry(namemap_, &hs);
  877.      he != NULL;
  878.      he = Tcl_NextHashEntry(&hs), i++) {
  879. pg = (ClientPage *) Tcl_GetHashValue(he);
  880. if (pg->server()->id() == sid)
  881. pg->server_down();
  882. }
  883. }
  886. // Proxy traces. Request file format:
  887. //
  888. // [<time> <clientID> <serverID> <URL_ID>]
  889. // i <Duration> <Number_of_unique_URLs>
  890. //
  891. // <time> is guaranteed to start from 0. It needs to be adjusted
  892. //
  893. // Page file format (sorted by access counts)
  894. // 
  895. // <serverID> <URL_ID> <PageSize> <AccessCount>
  897. static class ProxyTracePagePoolClass : public TclClass {
  898. public:
  899.         ProxyTracePagePoolClass() : TclClass("PagePool/ProxyTrace") {}
  900.         TclObject* create(int, const char*const*) {
  901. return (new ProxyTracePagePool());
  902. }
  903. } class_ProxyTracepagepool_agent;
  905. ProxyTracePagePool::ProxyTracePagePool() : 
  906. rvDyn_(NULL), rvStatic_(NULL), br_(0), 
  907. size_(NULL), reqfile_(NULL), req_(NULL), lastseq_(0)
  908. {
  909. }
  911. ProxyTracePagePool::~ProxyTracePagePool()
  912. {
  913. if (size_ != NULL) 
  914. delete []size_;
  915. if (reqfile_ != NULL) 
  916. fclose(reqfile_);
  917. if (req_ != NULL) {
  918. Tcl_DeleteHashTable(req_);
  919. delete req_;
  920. }
  921. }
  923. int ProxyTracePagePool::init_req(const char *fn) 
  924. {
  925. reqfile_ = fopen(fn, "r");
  926. if (reqfile_ == NULL) {
  927. fprintf(stderr, 
  928.   "ProxyTracePagePool: couldn't open trace file %sn", fn);
  929. return TCL_ERROR;
  930. }
  932. // Discover information about the trace, e.g., number of pages,
  933. // start time, end time, etc. They should be available at the 
  934. // first line of the trace file.
  935. return find_info();
  936. }
  938. int ProxyTracePagePool::find_info()
  939. {
  940. // Read the last line of the file
  941. fseek(reqfile_, -128, SEEK_END);
  942. char buf[129];
  943. if (fread(buf, 1, 128, reqfile_) != 128) {
  944. fprintf(stderr,
  945. "ProxyTracePagePool: cannot read file informationn");
  946. return TCL_ERROR;
  947. }
  948. int i;
  949. // ignore the last RETURN
  950. buf[128] = 0;
  951. if (buf[127] == 'n')
  952. buf[127] = 0; 
  953. for (i = 127; i >= 0; i--)
  954. if (buf[i] == 'n') {
  955. i++; 
  956. break;
  957. }
  958. if (buf[i] != 'i') {
  959. fprintf(stderr, 
  960. "ProxyTracePagePool: trace file doesn't contain statistics.n");
  961. abort();
  962. }
  963. double len;
  964. sscanf(buf+i+1, "%lf %i", &len, &num_pages_);
  965. duration_ = (int)ceil(len);
  966. #if 0
  967. printf("ProxyTracePagePool: duration %d pages %un",
  968.        duration_, num_pages_);
  969. #endif
  970. rewind(reqfile_);
  971. return TCL_OK;
  972. }
  974. // Load page size info. Assuming request stream has already been loaded
  975. int ProxyTracePagePool::init_page(const char *fn)
  976. {
  977. FILE *fp = fopen(fn, "r");
  978. if (fp == NULL) {
  979. fprintf(stderr, 
  980.   "ProxyTracePagePool: couldn't open trace file %sn", fn);
  981. return TCL_ERROR;
  982. }
  983. if (size_ != NULL) 
  984. delete []size_;
  985. int* p = new int[num_pages_];
  986. size_ = p;
  987. for (int i = 0; i < num_pages_; i++, p++)
  988. fscanf(fp, "%*d %*d %d %*un", p);
  989. fclose(fp);
  990. return TCL_OK;
  991. }
  993. ProxyTracePagePool::ClientRequest* ProxyTracePagePool::load_req(int cid)
  994. {
  995. // Find out which client we are seeking
  996. Tcl_HashEntry *he;
  997. ClientRequest *p;
  998. int dummy; 
  999. long key = cid;
  1000. if ((he = Tcl_FindHashEntry(req_, (const char*)key)) == NULL) {
  1001. // New entry
  1002. p = new ClientRequest();
  1003. p->seq_ = lastseq_++;
  1004. he = Tcl_CreateHashEntry(req_, (const char*)key, &dummy);
  1005. Tcl_SetHashValue(he, (const char*)p);
  1006. // Search from the beginning of file for this new client
  1007. fseek(reqfile_, 0, SEEK_SET);
  1008. } else {
  1009. p = (ClientRequest*)Tcl_GetHashValue(he);
  1010. if (p->nrt_ == -1)
  1011. // No more requests for this client
  1012. return p;
  1013. // Clear EOF status
  1014. fseek(reqfile_, p->fpos_, SEEK_SET);
  1015. }
  1017. // Looking for the next available request for this client
  1018. double nrt;
  1019. int ncid = -1, nurl;
  1020. char buf[256];
  1021. while (fgets(buf, 256, reqfile_)) {
  1022. if (isalpha(buf[0])) {
  1023. // Last line, break;
  1024. ncid = -1;
  1025. break;
  1026. }
  1027. sscanf(buf, "%lf %d %*d %dn", &nrt, &ncid, &nurl);
  1028. if ((ncid % nclient_) == p->seq_)
  1029. break;
  1030. }
  1031. if ((ncid % nclient_) != p->seq_)
  1032. // Didn't find the next request for this client
  1033. p->nrt_ = -1;
  1034. else {
  1035. p->nrt_ = nrt, p->nurl_ = nurl;
  1036. p->nrt_ += start_time_;
  1037. }
  1038. p->fpos_ = ftell(reqfile_);
  1039. return p;
  1040. }
  1042. // Provide a tcl interface compatible with MathPagePool
  1043. int ProxyTracePagePool::command(int argc, const char*const* argv)
  1044. {
  1045. Tcl& tcl = Tcl::instance();
  1047. if (argc == 2) {
  1048. if (strcmp(argv[1], "get-poolsize") == 0) { 
  1049. tcl.resultf("%u", num_pages_);
  1050. return TCL_OK;
  1051. } else if (strcmp(argv[1], "get-start-time") == 0) {
  1052. tcl.resultf("%.17g", start_time_);
  1053. return TCL_OK;
  1054. } else if (strcmp(argv[1], "get-duration") == 0) {
  1055. tcl.resultf("%d", duration_);
  1056. return TCL_OK;
  1057. } else if (strcmp(argv[1], "bimodal-ratio") == 0) {
  1058. tcl.resultf("%g", br_ / 10);
  1059. return TCL_OK;
  1060. }
  1061. } else if (argc == 3) {
  1062. if (strcmp(argv[1], "set-client-num") == 0) {
  1063. // Set the number of clients it'll access
  1064. // Cannot be changed once set
  1065. if (req_ != NULL)
  1066. return TCL_ERROR;
  1067. int num = atoi(argv[2]);
  1068. req_ = new Tcl_HashTable;
  1069. Tcl_InitHashTable(req_, TCL_ONE_WORD_KEYS);
  1070. nclient_ = num;
  1071. return TCL_OK;
  1072. } else if (strcmp(argv[1], "gen-request") == 0) {
  1073. // Use client id to get a corresponding request
  1074. int id = atoi(argv[2]);
  1075. ClientRequest *p = load_req(id);
  1076. if ((p->nrt_ >= 0) && 
  1077.     (p->nrt_ < Scheduler::instance().clock())) {
  1078. // XXX Do NOT treat this as an error, also
  1079. // do NOT disable further requests from this 
  1080. // client.
  1081. fprintf(stderr,
  1082. "%.17g: Wrong request time %g.n",
  1083. Scheduler::instance().clock(),
  1084. p->nrt_);
  1085. // XXX If it's a little bit older than current 
  1086. // time, let it be a little bit later than now
  1087. p->nrt_ = Scheduler::instance().clock()+0.001;
  1088. }
  1089. tcl.resultf("%lf %d", 
  1090.     p->nrt_ - Scheduler::instance().clock(), 
  1091.     p->nurl_);
  1092. return TCL_OK;
  1093. } else if (strcmp(argv[1], "gen-size") == 0) {
  1094. int id = atoi(argv[2]);
  1095. if ((id < 0) || (id > num_pages_)) {
  1096. tcl.result("PagePool: id out of range.n");
  1097. return TCL_ERROR;
  1098. }
  1099. tcl.resultf("%d", size_[id]);
  1100. return TCL_OK;
  1101. } else if (strcmp(argv[1], "set-start-time") == 0) {
  1102. start_time_ = strtod(argv[2], NULL);
  1103. return TCL_OK;
  1104. } else if (strcmp(argv[1], "bimodal-ratio") == 0) {
  1105. // XXX Codes in Http/Server::gen-page{} also depends
  1106. // on this dyn/static page algorithm. If this is 
  1107. // changed, that instproc must be changed too.
  1108. //
  1109. // percentage of dynamic pages. E.g., 
  1110. // if this ratio is 5, then page 0-4 is 
  1111. // dynamic, and page 4-99 is static, and so on.
  1112. double ratio = strtod(argv[2], NULL);
  1113. //br_ = (int)ceil(ratio*100);
  1114. br_ = (int)ceil(ratio*10);
  1115. return TCL_OK;
  1116. } else if (strcmp(argv[1], "ranvar-dp") == 0) {
  1117. // Page mod ranvar for dynamic pages
  1118. rvDyn_ = (RandomVariable*)TclObject::lookup(argv[2]);
  1119. return TCL_OK;
  1120. } else if (strcmp(argv[1], "ranvar-sp") == 0) {
  1121. // page mod ranvar for static pages
  1122. rvStatic_= (RandomVariable*)TclObject::lookup(argv[2]);
  1123. return TCL_OK;
  1124. } else if (strcmp(argv[1], "set-reqfile") == 0) {
  1125. return init_req(argv[2]);
  1126. } else if (strcmp(argv[1], "set-pagefile") == 0) {
  1127. return init_page(argv[2]);
  1128. } else if (strcmp(argv[1], "gen-init-modtime") == 0) {
  1129. int id = atoi(argv[2]) % 10;
  1130. if (id >= br_)
  1131. // Static page
  1132. tcl.result("0");
  1133. else
  1134. // Dynamic page
  1135. tcl.resultf("%.17g", 
  1136.     Scheduler::instance().clock());
  1137. return TCL_OK;
  1138. }
  1139. } else {
  1140. if (strcmp(argv[1], "gen-modtime") == 0) {
  1141. if ((rvDyn_ == 0) || (rvStatic_ == 0)) {
  1142. tcl.add_errorf("%s: no page age generator", 
  1143.        name_);
  1144. return TCL_ERROR;
  1145. }
  1146. // int id = atoi(argv[2]) % 100;
  1147. int id = atoi(argv[2]) % 10;
  1148. double mt = strtod(argv[3], NULL);
  1149. if (id >= br_) 
  1150. tcl.resultf("%.17g", mt + rvStatic_->value());
  1151. else 
  1152. tcl.resultf("%.17g", mt + rvDyn_->value());
  1153. return TCL_OK;
  1154. }
  1155. }
  1157. return PagePool::command(argc, argv);
  1158. }
  1161. // Proxy trace with special method for page modification
  1162. static class EPAPagePoolClass : public TclClass {
  1163. public:
  1164. EPAPagePoolClass() : TclClass("PagePool/ProxyTrace/epa") {}
  1165. TclObject* create(int, const char*const*) {
  1166. return (new EPATracePagePool());
  1167. }
  1168. } class_epapagepool_agent;
  1170. int EPATracePagePool::command(int argc, const char*const* argv)
  1171. {
  1172. Tcl& tcl = Tcl::instance();
  1173. if (argc == 2) {
  1174. if (strcmp(argv[1], "pick-pagemod") == 0) {
  1175. if (rvDyn_ == 0) {
  1176. tcl.add_errorf("%s: no page age generator",
  1177.        name_);
  1178. return (TCL_ERROR);
  1179. }
  1180. int j = (int)floor(rvDyn_->value());
  1181. //fprintf(stderr, "mod id = %dn", j/br_*10 + j % br_);
  1182. tcl.resultf("%d", j/br_*10 + j % br_);
  1183. return TCL_OK;
  1184. }
  1185. } else if (argc == 3) {
  1186. if (strcmp(argv[1], "ranvar-dp") == 0) {
  1187. rvDyn_ = (RandomVariable*)TclObject::lookup(argv[2]);
  1188. if (rvDyn_ == 0) {
  1189. tcl.add_errorf("%s: no page age generator",
  1190.        name_);
  1191. return (TCL_ERROR);
  1192. }
  1193. ((UniformRandomVariable*)rvDyn_)->setmin(0);
  1194. ((UniformRandomVariable*)rvDyn_)->setmax(num_pages_/10*br_ + num_pages_%br_ - 1);
  1195. return TCL_OK;
  1196. }
  1197. } else {
  1198. if (strcmp(argv[1], "gen-modtime") == 0) {
  1199. // Return a very large number
  1200. tcl.resultf("%d", INT_MAX);
  1201. return TCL_OK;
  1202. }
  1203. }
  1204. return ProxyTracePagePool::command(argc, argv);
  1205. }