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

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

通讯编程

开发平台：

Visual C++

dsPolicy.cc：源码内容
  1. /*
  2.  * Copyright (c) 2000 Nortel Networks
  3.  * All rights reserved.
  4.  * 
  5.  * Redistribution and use in source and binary forms, with or without
  6.  * modification, are permitted provided that the following conditions
  7.  * are met:
  8.  * 1. Redistributions of source code must retain the above copyright
  9.  *    notice, this list of conditions and the following disclaimer.
  10.  * 2. Redistributions in binary form must reproduce the above copyright
  11.  *    notice, this list of conditions and the following disclaimer in the
  12.  *    documentation and/or other materials provided with the distribution.
  13.  * 3. All advertising materials mentioning features or use of this software
  14.  *    must display the following acknowledgement:
  15.  *      This product includes software developed by Nortel Networks.
  16.  * 4. The name of the Nortel Networks may not be used
  17.  *    to endorse or promote products derived from this software without
  18.  *    specific prior written permission.
  19.  * 
  20.  * THIS SOFTWARE IS PROVIDED BY NORTEL AND CONTRIBUTORS ``AS IS'' AND
  21.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23.  * ARE DISCLAIMED.  IN NO EVENT SHALL NORTEL OR CONTRIBUTORS BE LIABLE
  24.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  25.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  26.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  27.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  28.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  29.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  30.  * SUCH DAMAGE.
  31.  *
  32.  * Developed by: Farhan Shallwani, Jeremy Ethridge
  33.  *               Peter Pieda, and Mandeep Baines
  34.  * Maintainer: Peter Pieda <ppieda@nortelnetworks.com>
  35.  */
  37. /* 
  38.  *  Integrated into ns main distribution and reorganized by 
  39.  *  Xuan Chen (xuanc@isi.edu). The main changes are:
  40.  *
  41.  *  1. Defined two seperated classes, PolicyClassifier and Policy, to handle 
  42.  *     the work done by class Policy before.
  43.  *     Class PolicyClassifier now only keeps states for each flow and pointers
  44.  *     to certain policies. 
  45.  *     The policies perform the diffserv related jobs as described
  46.  *     below. (eg, traffic metering and packet marking.)
  47.  *     class Policy functions like the class Classifer.
  48.  *
  49.  *  2. Created a general supper class Policy so that new policy can be added
  50.  *     by just creating a subclass of Policy. Examples are given (eg, 
  51.  *     DumbPolicy) to help people trying to add their own new policies.
  52.  *
  53.  *  TODO:
  54.  *  1. implement the multiple policy support by applying the idea of 
  55.  *     multi-policy.
  56.  *
  57.  */
  59. #include "dsPolicy.h"
  60. #include "ew.h"
  61. #include "dewp.h"
  62. #include "packet.h"
  63. #include "tcp.h"
  64. #include "random.h"
  66. // The definition of class PolicyClassifier.
  67. //Constructor.
  68. PolicyClassifier::PolicyClassifier() {
  69.   int i;
  71.   policyTableSize = 0;
  72.   policerTableSize = 0;
  74.   for (i = 0; i < MAX_POLICIES; i++) 
  75.     policy_pool[i] = NULL;
  76. }
  78. /*-----------------------------------------------------------------------------
  79. void addPolicyEntry()
  80.     Adds an entry to policyTable according to the arguments in argv.  A source
  81. and destination node ID must be specified in argv, followed by a policy type
  82. and policy-specific parameters.  Supported policies and their parameters
  83. are:
  85. Null          InitialCodePoint
  86. TSW2CM        InitialCodePoint  CIR
  87. TSW3CM        InitialCodePoint  CIR  PIR
  88. TokenBucket   InitialCodePoint  CIR  CBS
  89. srTCM         InitialCodePoint  CIR  CBS  EBS
  90. trTCM         InitialCodePoint  CIR  CBS  PIR  PBS
  92.     No error-checking is performed on the parameters.  CIR and PIR should be
  93. specified in bits per second; CBS, EBS, and PBS should be specified in bytes.
  95.     If the Policy Table is full, this method prints an error message.
  96. -----------------------------------------------------------------------------*/
  97. void PolicyClassifier::addPolicyEntry(int argc, const char*const* argv) {
  98.   if (policyTableSize == MAX_POLICIES)
  99.     printf("ERROR: Policy Table size limit exceeded.n");
  100.   else {
  101.     policyTable[policyTableSize].sourceNode = atoi(argv[2]);
  102.     policyTable[policyTableSize].destNode = atoi(argv[3]);
  103.     policyTable[policyTableSize].codePt = atoi(argv[5]);
  104.     policyTable[policyTableSize].arrivalTime = 0;
  105.     policyTable[policyTableSize].winLen = 1.0;
  106.     
  107.     if ((strcmp(argv[4], "Dumb") == 0) || (strcmp(argv[4],"Null") == 0)) {
  108.       if(!policy_pool[Null])
  109. policy_pool[Null] = new NullPolicy;
  110.       policyTable[policyTableSize].policy_index = Null;   
  111.       policyTable[policyTableSize].policer = nullPolicer;
  112.       policyTable[policyTableSize].meter = nullMeter;
  113.     } else if (strcmp(argv[4], "TSW2CM") == 0) {
  114.       if(!policy_pool[TSW2CM])
  115. policy_pool[TSW2CM] = new TSW2CMPolicy;
  116.       policyTable[policyTableSize].policy_index = TSW2CM;   
  117.       policyTable[policyTableSize].policer = TSW2CMPolicer;
  118.       policyTable[policyTableSize].meter = tswTagger;
  120.       policyTable[policyTableSize].cir =
  121. policyTable[policyTableSize].avgRate = (double) atof(argv[6]) / 8.0;
  122.       if (argc == 8) policyTable[policyTableSize].winLen = (double) atof(argv[7]);/* mb */
  123.     } else if (strcmp(argv[4], "TSW3CM") == 0) {
  124.       if(!policy_pool[TSW3CM])
  125. policy_pool[TSW3CM] = new TSW3CMPolicy;
  126.       policyTable[policyTableSize].policy_index = TSW3CM;   
  127.       policyTable[policyTableSize].policer = TSW3CMPolicer;
  128.       policyTable[policyTableSize].meter = tswTagger;
  130.       policyTable[policyTableSize].cir =
  131. policyTable[policyTableSize].avgRate = (double) atof(argv[6]) / 8.0;
  132.       policyTable[policyTableSize].pir = (double) atof(argv[7]) / 8.0;
  133.     } else if (strcmp(argv[4], "TokenBucket") == 0) {
  134.       if(!policy_pool[TB])
  135. policy_pool[TB] = (Policy *) new TBPolicy;
  136.       policyTable[policyTableSize].policy_index = TB;   
  137.       policyTable[policyTableSize].policer = tokenBucketPolicer;
  138.       policyTable[policyTableSize].meter = tokenBucketMeter;
  139.       
  140.       policyTable[policyTableSize].cir =
  141. policyTable[policyTableSize].avgRate = (double) atof(argv[6]) / 8.0;
  142.       policyTable[policyTableSize].cbs =
  143. policyTable[policyTableSize].cBucket = (double) atof(argv[7]);
  144.     } else if (strcmp(argv[4], "srTCM") == 0) {
  145.       if(!policy_pool[SRTCM])
  146. policy_pool[SRTCM] = new SRTCMPolicy;
  147.       policyTable[policyTableSize].policy_index = SRTCM;   
  148.       policyTable[policyTableSize].policer = srTCMPolicer;
  149.       policyTable[policyTableSize].meter = srTCMMeter;      
  151.       policyTable[policyTableSize].cir =
  152. policyTable[policyTableSize].avgRate = (double) atof(argv[6]) / 8.0;
  153.       policyTable[policyTableSize].cbs =
  154. policyTable[policyTableSize].cBucket = (double) atof(argv[7]);
  155.       policyTable[policyTableSize].ebs =
  156. policyTable[policyTableSize].eBucket = (double) atof(argv[8]);
  157.     } else if (strcmp(argv[4], "trTCM") == 0) {
  158.       if(!policy_pool[TRTCM])
  159. policy_pool[TRTCM] = new TRTCMPolicy;
  160.       policyTable[policyTableSize].policy_index = TRTCM;  
  161.       policyTable[policyTableSize].policer = trTCMPolicer;
  162.       policyTable[policyTableSize].meter = trTCMMeter;
  163.       
  164.       policyTable[policyTableSize].cir =
  165. policyTable[policyTableSize].avgRate = (double) atof(argv[6]) / 8.0;
  166.       policyTable[policyTableSize].cbs =
  167. policyTable[policyTableSize].cBucket = (double) atof(argv[7]);
  168.       policyTable[policyTableSize].pir = (double) atof(argv[8]) / 8.0;
  169.       policyTable[policyTableSize].pbs =
  170. policyTable[policyTableSize].pBucket = (double) atof(argv[9]);
  171.     } else if (strcmp(argv[4], "SFD") == 0) {
  172.       if(!policy_pool[SFD])
  173. policy_pool[SFD] = new SFDPolicy;
  174.       policyTable[policyTableSize].policy_index = SFD;
  175.       policyTable[policyTableSize].policer = SFDPolicer;
  176.       policyTable[policyTableSize].meter = sfdTagger;
  178.       // Use cir as the transmission size threshold for the moment.
  179.       policyTable[policyTableSize].cir = atoi(argv[6]);
  180.     } else if (strcmp(argv[4], "EW") == 0) {
  181.       if(!policy_pool[EW])
  182. policy_pool[EW] = new EWPolicy();
  183.       
  184.       ((EWPolicy *)policy_pool[EW])->
  185. init(atoi(argv[6]), atoi(argv[7]), atoi(argv[8]));
  187.       policyTable[policyTableSize].policy_index = EW;
  188.       policyTable[policyTableSize].policer = EWPolicer;
  189.       policyTable[policyTableSize].meter = ewTagger;
  190.   } else if (strcmp(argv[4], "DEWP") == 0) {
  191.     if(!policy_pool[DEWP])
  192.       policy_pool[DEWP] = new DEWPPolicy;
  194.     ((DEWPPolicy *)policy_pool[DEWP])->
  195.       init(atof(argv[6]));
  196.     
  197.     policyTable[policyTableSize].policy_index = DEWP;
  198.     policyTable[policyTableSize].policer = DEWPPolicer;
  199.     policyTable[policyTableSize].meter = dewpTagger;
  200.   } else {
  201.       printf("No applicable policy specified, exit!!!n");
  202.       exit(-1);
  203.     }
  204.     policyTableSize++;
  205.   }
  206. }
  208. /*-----------------------------------------------------------------------------
  209. policyTableEntry* PolicyClassifier::getPolicyTableEntry(long source, long dest)
  210. Pre: policyTable holds exactly one entry for the specified source-dest pair.
  211. Post: Finds the policyTable array that matches the specified source-dest pair.
  212. Returns: On success, returns a pointer to the corresponding policyTableEntry;
  213.   on failure, returns NULL.
  214. Note: the source-destination pair could be one-any or any-any (xuanc)
  215. -----------------------------------------------------------------------------*/
  216. policyTableEntry* PolicyClassifier::getPolicyTableEntry(nsaddr_t source, nsaddr_t dest) {
  217.   for (int i = 0; i <= policyTableSize; i++) {
  218.     if ((policyTable[i].sourceNode == source) || (policyTable[i].sourceNode == ANY_HOST)) {
  219.       if ((policyTable[i].destNode == dest) || (policyTable[i].destNode == ANY_HOST))
  220. return(&policyTable[i]);
  221.     }
  222.   }
  223.   
  224.   // !!! Could make a default code point for undefined flows:
  225.   printf("ERROR: No Policy Table entry found for Source %d-Destination %d.n", source, dest);
  226.   printPolicyTable();
  227.   return(NULL);
  228. }
  230. /*-----------------------------------------------------------------------------
  231. void addPolicerEntry(int argc, const char*const* argv)
  232. Pre: argv contains a valid command line for adding a policer entry.
  233. Post: Adds an entry to policerTable according to the arguments in argv.  No
  234.   error-checking is done on the arguments.  A policer type should be specified,
  235.   consisting of one of the names {Null, TSW2CM, TSW3CM, TokenBucket,
  236.   srTCM, trTCM}, followed by an initial code point.  Next should be an
  237.   out-of-profile code point for policers with two-rate markers; or a yellow and
  238.   a red code point for policers with three drop precedences.
  239.       If policerTable is full, an error message is printed.
  240. -----------------------------------------------------------------------------*/
  241. void PolicyClassifier::addPolicerEntry(int argc, const char*const* argv) {
  242.   //int cur_policy;
  245.   if (policerTableSize == MAX_CP)
  246.     printf("ERROR: Policer Table size limit exceeded.n");
  247.   else {
  248.     if ((strcmp(argv[2], "Dumb") == 0) || (strcmp(argv[2],"Null") == 0)) {
  249.       if(!policy_pool[Null])
  250. policy_pool[Null] = new NullPolicy;
  251.       policerTable[policerTableSize].policer = nullPolicer;      
  252.       policerTable[policerTableSize].policy_index = Null;      
  253.     } else if (strcmp(argv[2], "TSW2CM") == 0) {
  254.       if(!policy_pool[TSW2CM])
  255. policy_pool[TSW2CM] = new TSW2CMPolicy;
  256.       policerTable[policerTableSize].policer = TSW2CMPolicer;
  257.       policerTable[policerTableSize].policy_index = TSW2CM;      
  258.     } else if (strcmp(argv[2], "TSW3CM") == 0) {
  259.       if(!policy_pool[TSW3CM])
  260. policy_pool[TSW3CM] = new TSW3CMPolicy;
  261.       policerTable[policerTableSize].policer = TSW3CMPolicer;
  262.       policerTable[policerTableSize].policy_index = TSW3CM;      
  263.     } else if (strcmp(argv[2], "TokenBucket") == 0) {
  264.       if(!policy_pool[TB])
  265. policy_pool[TB] = new TBPolicy;
  266.       policerTable[policerTableSize].policer = tokenBucketPolicer;
  267.       policerTable[policerTableSize].policy_index = TB;      
  268.     } else if (strcmp(argv[2], "srTCM") == 0) {
  269.       if(!policy_pool[SRTCM])
  270. policy_pool[SRTCM] = new SRTCMPolicy;
  271.       policerTable[policerTableSize].policer = srTCMPolicer;
  272.       policerTable[policerTableSize].policy_index = SRTCM;      
  273.     } else if (strcmp(argv[2], "trTCM") == 0){
  274.       if(!policy_pool[TRTCM])
  275. policy_pool[TRTCM] = new TRTCMPolicy;
  276.       policerTable[policerTableSize].policer = trTCMPolicer;
  277.       policerTable[policerTableSize].policy_index = TRTCM;      
  278.     } else if (strcmp(argv[2], "SFD") == 0) {
  279.       if(!policy_pool[SFD])
  280. policy_pool[SFD] = new SFDPolicy;
  281.       policerTable[policerTableSize].policer = SFDPolicer;
  282.       policerTable[policerTableSize].policy_index = SFD;      
  283.     } else if (strcmp(argv[2], "EW") == 0) {
  284.       if(!policy_pool[EW])
  285. policy_pool[EW] = new EWPolicy;
  286.       policerTable[policerTableSize].policer = EWPolicer;
  287.       policerTable[policerTableSize].policy_index = EW;      
  288.     } else if (strcmp(argv[2], "DEWP") == 0) {
  289.       if(!policy_pool[DEWP])
  290. policy_pool[DEWP] = new DEWPPolicy;
  291.       policerTable[policerTableSize].policer = DEWPPolicer;
  292.       policerTable[policerTableSize].policy_index = DEWP;      
  293.     } else {
  294.       printf("No applicable policer specified, exit!!!n");
  295.       exit(-1);
  296.     }
  297.   };
  298.   
  299.   policerTable[policerTableSize].initialCodePt = atoi(argv[3]);
  300.   if (policerTable[policerTableSize].policer == nullPolicer)
  301.       policerTable[policerTableSize].downgrade1 = atoi(argv[3]);
  302.     else
  303.       policerTable[policerTableSize].downgrade1 = atoi(argv[4]);
  304.   if (argc == 6)
  305.     policerTable[policerTableSize].downgrade2 = atoi(argv[5]);
  306.   policerTableSize++;
  307. }
  309. // Return the entry of Policer table with policerType and initCodePoint matched
  310. policerTableEntry* PolicyClassifier::getPolicerTableEntry(int policy_index, int oldCodePt) {
  311.   for (int i = 0; i < policerTableSize; i++)
  312.     if ((policerTable[i].policy_index == policy_index) &&
  313. (policerTable[i].initialCodePt == oldCodePt))
  314.       return(&policerTable[i]);
  316.   printf("ERROR: No Policer Table entry found for initial code point %d.n", oldCodePt);
  317.   //printPolicerTable();
  318.   return(NULL);
  319. }
  321. /*-----------------------------------------------------------------------------
  322. int mark(Packet *pkt, double minRTT)
  323. Pre: The source-destination pair taken from pkt matches a valid entry in
  324.   policyTable.
  325. Post: pkt is marked with an appropriate code point.
  326. -----------------------------------------------------------------------------*/
  327. int PolicyClassifier::mark(Packet *pkt) {
  328.   policyTableEntry *policy;
  329.   policerTableEntry *policer;
  330.   int policy_index;
  331.   int codePt;
  332.   hdr_ip* iph;
  333.   int fid;
  334.   
  335.   iph = hdr_ip::access(pkt);
  336.   fid = iph->flowid();
  337.   policy = getPolicyTableEntry(iph->saddr(), iph->daddr());
  338.   if (policy) {
  339.     codePt = policy->codePt;
  340.     policy_index = policy->policy_index;
  341.     policer = getPolicerTableEntry(policy_index, codePt);
  343.     // bug pointed by Jason Kenney <jason@linear.engmath.dal.ca>
  344.     if (policy_pool[policy_index]) {
  345.       policy_pool[policy_index]->applyMeter(policy, pkt);
  346.       codePt = policy_pool[policy_index]->applyPolicer(policy, policer, pkt);
  347.     }
  348.   } else {
  349.     printf("The policy object doesn't exist, ERROR!!!n");
  350.     exit(-1);    
  351.   }
  352.   
  353.   iph->prio_ = codePt;
  354.   return(codePt);
  355. }
  357. /*-----------------------------------------------------------------------------
  358. Pre: The command line specifies a source and destination node for which an
  359.   RTT-Aware policy exists and a current RTT value for that policy.
  360. Post: The aggRTT field of the appropriate policy is updated to a weighted
  361.   average of the previous value and the new RTT value specified in the command
  362.   line.  If no matching policy is found, an error message is printed.
  363. -----------------------------------------------------------------------------*/
  364. void PolicyClassifier::updatePolicyRTT(int argc, const char*const* argv) {
  365.   policyTableEntry *policy;
  366.   
  367.   policy = getPolicyTableEntry(atoi(argv[2]), atoi(argv[3]));
  368.   if (policy == NULL)
  369.     printf("ERROR: cannot update RTT; no existing policy found for Source %d-Desination %d.n",
  370.    atoi(argv[2]), atoi(argv[3]));
  371.   else {
  372.     policy->winLen = (double) atof(argv[4]);
  373.   }
  374. }
  376. /*-----------------------------------------------------------------------------
  377. Pre: The command line specifies a source and destination node for which a
  378.   policy exists that uses a cBucket value.  That policy's cBucket parameter is
  379.   currently valid.
  380. Post: The policy's cBucket value is found and returned.
  381. Returns: The value cBucket on success; or -1 on an error.
  382. -----------------------------------------------------------------------------*/
  383. double PolicyClassifier::getCBucket(const char*const* argv) {
  384.   policyTableEntry *policy;
  385.   
  386.   policy = getPolicyTableEntry(atoi(argv[2]), atoi(argv[3]));
  387.   if (policy == NULL) {
  388.     printf("ERROR: cannot get bucket size; no existing policy found for Source %d-Desination %d.n",
  389.    atoi(argv[2]), atoi(argv[3]));
  390.     return(-1);
  391.   }
  392.   else {
  393.     if ((policy->policer == tokenBucketPolicer) || (policy->policer == srTCMPolicer) || (policy->policer == trTCMPolicer))
  394.       return(policy->cBucket);
  395.     else {
  396.       printf("ERROR: cannot get bucket size; the Source %d-Desination %d Policy does not include a Committed Bucket.n", atoi(argv[2]), atoi(argv[3]));
  397.       return(-1);
  398.     }
  399.   }
  400. }
  402. //    Prints the policyTable, one entry per line.
  403. void PolicyClassifier::printPolicyTable() {
  404.   printf("Policy Table(%d):n",policyTableSize);
  405.   for (int i = 0; i < policyTableSize; i++)
  406.     {
  407.       switch (policyTable[i].policer) {
  408.       case nullPolicer:
  409. printf("Flow (%d to %d): Null policer, ",
  410.                policyTable[i].sourceNode,policyTable[i].destNode);
  411. printf("initial code point %dn", policyTable[i].codePt);
  412. break;
  413.       case TSW2CMPolicer:
  414. printf("Flow (%d to %d): TSW2CM policer, ",
  415.                policyTable[i].sourceNode,policyTable[i].destNode);
  416. printf("initial code point %d, CIR %.1f bps.n",
  417.                policyTable[i].codePt, policyTable[i].cir * 8);
  418. break;
  419.       case TSW3CMPolicer:
  420. printf("Flow (%d to %d): TSW3CM policer, initial code ",
  421.                policyTable[i].sourceNode, policyTable[i].destNode);
  422. printf("point %d, CIR %.1f bps, PIR %.1f bytes.n",
  423.                policyTable[i].codePt, policyTable[i].cir * 8,
  424.                policyTable[i].pir * 8);
  425. break;
  426.       case tokenBucketPolicer:
  427. printf("Flow (%d to %d): Token Bucket policer, ",
  428.                policyTable[i].sourceNode,policyTable[i].destNode);
  429. printf("initial code  point %d, CIR %.1f bps, CBS %.1f bytes.n",
  430.                policyTable[i].codePt, policyTable[i].cir * 8,
  431.                policyTable[i].cbs);
  432. break;
  433.       case srTCMPolicer:
  434. printf("Flow (%d to %d): srTCM policer, initial code ",
  435.                policyTable[i].sourceNode, policyTable[i].destNode);
  436. printf("point %d, CIR %.1f bps, CBS %.1f bytes, EBS %.1f bytes.n",
  437.                policyTable[i].codePt, policyTable[i].cir * 8,
  438.                policyTable[i].cbs, policyTable[i].ebs);
  439. break;
  440.       case trTCMPolicer:
  441. printf("Flow (%d to %d): trTCM policer, initial code ",
  442.                policyTable[i].destNode, policyTable[i].sourceNode);
  443. printf("point %d, CIR %.1f bps, CBS %.1f bytes, PIR %.1f bps, ",
  444.        policyTable[i].codePt, policyTable[i].cir * 8,
  445.                policyTable[i].cbs, policyTable[i].pir * 8);
  446. printf("PBS %.1f bytes.n", policyTable[i].pbs);
  447. break;
  448.       case SFDPolicer:
  449. printf("Flow (%d to %d): SFD policer, ",
  450.        policyTable[i].sourceNode,policyTable[i].destNode);
  451. printf("initial code point %d, TH %d bytes.n",
  452.        policyTable[i].codePt, (int)policyTable[i].cir);
  453. break;
  454.       case EWPolicer:
  455. printf("Flow (%d to %d): EW policer, ",
  456.        policyTable[i].sourceNode,policyTable[i].destNode);
  457. printf("initial code point %d.n", policyTable[i].codePt);
  458. break;
  459.       case DEWPPolicer:
  460. printf("Flow (%d to %d): DEWP policer, ",
  461.        policyTable[i].sourceNode,policyTable[i].destNode);
  462. printf("initial code point %d.n", policyTable[i].codePt);
  463. break;
  464.       default:
  465. printf("ERROR: Unknown policer type in Policy Table.n");
  466.       }
  467.     }
  468.   printf("n");
  469. }
  471. // Prints the policerTable, one entry per line.
  472. void PolicyClassifier::printPolicerTable() {
  473.   bool threeColor;
  474.   
  475.   printf("Policer Table:n");
  476.   for (int i = 0; i < policerTableSize; i++) {
  477.     threeColor = false;
  478.     switch (policerTable[i].policer) {
  479.     case nullPolicer:
  480.       printf("Null ");
  481.       break;
  482.     case TSW2CMPolicer:
  483.       printf("TSW2CM ");
  484.       break;
  485.     case TSW3CMPolicer:
  486.       printf("TSW3CM ");
  487.       threeColor = true;
  488.       break;
  489.     case tokenBucketPolicer:
  490.       printf("Token Bucket ");
  491.       break;
  492.     case srTCMPolicer:
  493.       printf("srTCM ");
  494.       threeColor = true;
  495.       break;
  496.     case trTCMPolicer:
  497.       printf("trTCM ");
  498.       threeColor = true;
  499.       break;
  500.     case SFDPolicer:
  501.       printf("SFD ");
  502.       //printFlowTable();
  503.       break;
  504.     case EWPolicer:
  505.       printf("EW ");
  506.       break;
  507.     case DEWPPolicer:
  508.       printf("DEWP ");
  509.       break;
  510.     default:
  511.       printf("ERROR: Unknown policer type in Policer Table.");
  512.     }
  513.     
  514.     if (threeColor) {
  515.       printf("policer code point %d is policed to yellow ",
  516.      policerTable[i].initialCodePt);
  517.       printf("code point %d and red code point %d.n",
  518.      policerTable[i].downgrade1,
  519.      policerTable[i].downgrade2);
  520.     } else
  521.       printf("policer code point %d is policed to code point %d.n",
  522.      policerTable[i].initialCodePt,
  523.      policerTable[i].downgrade1);
  524.   }
  525.   printf("n");
  526. }
  528. // The beginning of the definition of the NullPolicy
  529. // NullPolicy will do nothing, but is also a good example to show how to add 
  530. // new policy.
  532. /*-----------------------------------------------------------------------------
  533. void NullPolicy::applyMeter(policyTableEntry *policy, Packet *pkt)
  534. Do nothing
  535. -----------------------------------------------------------------------------*/
  536. void NullPolicy::applyMeter(policyTableEntry *policy, Packet *pkt) {
  537.   policy->arrivalTime = Scheduler::instance().clock();  
  538. }
  540. /*-----------------------------------------------------------------------------
  541. int DumbPolicy::applyPolicer(policyTableEntry *policy, int initialCodePt, Packet *pkt)
  542. Always return the initial codepoint.
  543. -----------------------------------------------------------------------------*/
  544. int NullPolicy::applyPolicer(policyTableEntry *policy, policerTableEntry *policer, Packet *pkt) {
  545.   return(policer->initialCodePt);
  546. }
  548. // The end of NullPolicy
  550. // The beginning of the definition of TSW2CM
  551. /*-----------------------------------------------------------------------------
  552. void TSW2CMPolicy::applyMeter(policyTableEntry *policy, Packet *pkt)
  553. Pre: policy's variables avgRate, arrivalTime, and winLen hold valid values; and
  554.   pkt points to a newly-arrived packet.
  555. Post: Adjusts policy's TSW state variables avgRate and arrivalTime (also called
  556.   tFront) according to the specified packet.
  557. Note: See the paper "Explicit Allocation of Best effor Delivery Service" (David
  558.   Clark and Wenjia Fang), Section 3.3, for a description of the TSW Tagger.
  559. -----------------------------------------------------------------------------*/
  560. void TSW2CMPolicy::applyMeter(policyTableEntry *policy, Packet *pkt) {
  561.   double now, bytesInTSW, newBytes;
  562.   hdr_cmn* hdr = hdr_cmn::access(pkt);
  563.   
  564.   bytesInTSW = policy->avgRate * policy->winLen;
  565.   newBytes = bytesInTSW + (double) hdr->size();
  566.   now = Scheduler::instance().clock();
  567.   policy->avgRate = newBytes / (now - policy->arrivalTime + policy->winLen);
  568.   policy->arrivalTime = now;
  569. }
  571. /*-----------------------------------------------------------------------------
  572. int TSW2CMPolicy::applyPolicer(policyTableEntry *policy, int initialCodePt, Packet *pkt)
  573. Pre: policy points to a policytableEntry that is using the TSW2CM policer and
  574.   whose state variables (avgRate and cir) are up to date.
  575. Post: If policy's avgRate exceeds its CIR, this method returns an out-of-profile
  576.   code point with a probability of ((rate - CIR) / rate).  If it does not
  577.   downgrade the code point, this method simply returns the initial code point.
  578. Returns: A code point to apply to the current packet.
  579. Uses: Method downgradeOne().
  580. -----------------------------------------------------------------------------*/
  581. int TSW2CMPolicy::applyPolicer(policyTableEntry *policy, policerTableEntry *policer, Packet *pkt) {
  582.   if ((policy->avgRate > policy->cir)
  583.       && (Random::uniform(0.0, 1.0) <= (1-(policy->cir/policy->avgRate)))) {
  584.     return(policer->downgrade1);
  585.   }
  586.   else {
  587.     return(policer->initialCodePt);
  588.   }
  589. }
  591. // The end of TSW2CM
  593. // The Beginning of TSW3CM
  594. /*-----------------------------------------------------------------------------
  595. void TSW3CMPolicy::applyMeter(policyTableEntry *policy, Packet *pkt)
  596. Pre: policy's variables avgRate, arrivalTime, and winLen hold valid values; and
  597.   pkt points to a newly-arrived packet.
  598. Post: Adjusts policy's TSW state variables avgRate and arrivalTime (also called
  599.   tFront) according to the specified packet.
  600. Note: See the paper "Explicit Allocation of Best effor Delivery Service" (David
  601.   Clark and Wenjia Fang), Section 3.3, for a description of the TSW Tagger.
  602. -----------------------------------------------------------------------------*/
  603. void TSW3CMPolicy::applyMeter(policyTableEntry *policy, Packet *pkt) {
  604.   double now, bytesInTSW, newBytes;
  605.   hdr_cmn* hdr = hdr_cmn::access(pkt);
  606.   
  607.   bytesInTSW = policy->avgRate * policy->winLen;
  608.   newBytes = bytesInTSW + (double) hdr->size();
  609.   now = Scheduler::instance().clock();
  610.   policy->avgRate = newBytes / (now - policy->arrivalTime + policy->winLen);
  611.   policy->arrivalTime = now;
  612. }
  614. /*-----------------------------------------------------------------------------
  615. int TSW3CMPolicy::applyPolicer(policyTableEntry *policy, int initialCodePt, Packet *pkt)
  616. Pre: policy points to a policytableEntry that is using the TSW3CM policer and
  617.   whose state variables (avgRate, cir, and pir) are up to date.
  618. Post: Sets code points with the following probabilities when rate > PIR:
  620.           red:    (rate - PIR) / rate
  621.           yellow: (PIR - CIR) / rate
  622.           green:  CIR / rate
  624. and with the following code points when CIR < rate <= PIR:
  626.           red:    0
  627.           yellow: (rate - CIR) / rate
  628.           green:  CIR / rate
  630.     When rate is under CIR, a packet is always marked green.
  631. Returns: A code point to apply to the current packet.
  632. Uses: Methods downgradeOne() and downgradeTwo().
  633. -----------------------------------------------------------------------------*/
  634. int TSW3CMPolicy::applyPolicer(policyTableEntry *policy, policerTableEntry *policer, Packet *pkt) {
  635.   double rand = policy->avgRate * (1.0 - Random::uniform(0.0, 1.0));
  636.   
  637.   if (rand > policy->pir)
  638.     return (policer->downgrade2);
  639.   else if (rand > policy->cir)
  640.     return(policer->downgrade1);
  641.   else
  642.     return(policer->initialCodePt);
  643. }
  644.  
  645. // End of TSW3CM
  647. // Begin of Token Bucket.
  648. /*-----------------------------------------------------------------------------
  649. void TBPolicy::applyMeter(policyTableEntry *policy, Packet *pkt)
  650. Pre: policy's variables cBucket, cir, cbs, and arrivalTime hold valid values.
  651. Post: Increments policy's Token Bucket state variable cBucket according to the
  652.   elapsed time since the last packet arrival.  cBucket is filled at a rate equal  to CIR, capped at an upper bound of CBS.
  653.   This method also sets arrivalTime equal to the current simulator time.
  654. -----------------------------------------------------------------------------*/
  655. void TBPolicy::applyMeter(policyTableEntry *policy, Packet *pkt) {
  656.   double now = Scheduler::instance().clock();
  657.   double tokenBytes;
  659.   tokenBytes = (double) policy->cir * (now - policy->arrivalTime);
  660.   if (policy->cBucket + tokenBytes <= policy->cbs)
  661.    policy->cBucket += tokenBytes;
  662.   else
  663.    policy->cBucket = policy->cbs;
  664.   policy->arrivalTime = now;
  665. }
  667. /*----------------------------------------------------------------------------
  668. int TBPolicy::applyPolicer(policyTableEntry *policy, int initialCodePt,
  669.         Packet* pkt)
  670. Pre: policy points to a policytableEntry that is using the Token Bucket policer
  671. and whose state variable (cBucket) is up to date.  pkt points to a
  672. newly-arrived packet.
  673. Post: If policy's cBucket is at least as large as pkt's size, cBucket is
  674. decremented by that size and the initial code point is retained.  Otherwise,
  675. the code point is downgraded.
  676. Returns: A code point to apply to the current packet.
  677. Uses: Method downgradeOne().
  678. -----------------------------------------------------------------------------*/
  679. int TBPolicy::applyPolicer(policyTableEntry *policy, policerTableEntry *policer, Packet* pkt) {
  680.   hdr_cmn* hdr = hdr_cmn::access(pkt);
  682.   double size = (double) hdr->size();
  684.   if ((policy->cBucket - size) >= 0) {
  685.     policy->cBucket -= size;
  686.     return(policer->initialCodePt);
  687.   } else{
  688.     return(policer->downgrade1);
  689.   }
  690. }
  692. // End of Tocken Bucket.
  694. // Begining of SRTCM
  695. /*-----------------------------------------------------------------------------
  696. void SRTCMPolicy::applyMeter(policyTableEntry *policy)
  697. Pre: policy's variables cBucket, eBucket, cir, cbs, ebs, and arrivalTime hold
  698.   valid values.
  699. Post: Increments policy's srTCM state variables cBucket and eBucket according
  700.   to the elapsed time since the last packet arrival.  cBucket is filled at a
  701.   rate equal to CIR, capped at an upper bound of CBS.  When cBucket is full
  702.   (equal to CBS), eBucket is filled at a rate equal to CIR, capped at an upper
  703.   bound of EBS.
  704.       This method also sets arrivalTime equal to the current
  705.   simulator time.
  706. Note: See the Internet Draft, "A Single Rate Three Color Marker" (Heinanen et
  707.   al; May, 1999) for a description of the srTCM.
  708. -----------------------------------------------------------------------------*/
  709. void SRTCMPolicy::applyMeter(policyTableEntry *policy, Packet *pkt) {
  710.   double now = Scheduler::instance().clock();
  711.   double tokenBytes;
  712.   
  713.   tokenBytes = (double) policy->cir * (now - policy->arrivalTime);
  714.   if (policy->cBucket + tokenBytes <= policy->cbs)
  715.     policy->cBucket += tokenBytes;
  716.   else {
  717.     tokenBytes = tokenBytes - (policy->cbs - policy->cBucket);
  718.     
  719.     policy->cBucket = policy->cbs;
  720.     if (policy->eBucket + tokenBytes <= policy->ebs)
  721.       policy->eBucket += tokenBytes;
  722.     else
  723.       policy->eBucket = policy->ebs;
  724.   }
  725.   policy->arrivalTime = now;
  726. }
  728. /*-----------------------------------------------------------------------------
  729. int SRTCMPolicy::applyPolicer(policyTableEntry *policy, int initialCodePt, Packet* pkt)
  730. Pre: policy points to a policyTableEntry that is using the srTCM policer and
  731.   whose state variables (cBucket and eBucket) are up to date.  pkt points to a
  732.   newly-arrived packet.
  733. Post: If policy's cBucket is at least as large as pkt's size, cBucket is
  734.   decremented by that size and the initial code point is retained.  Otherwise,
  735.   if eBucket is at least as large as the packet, eBucket is decremented and the
  736.   yellow code point is returned.  Otherwise, the red code point is returned.
  737. Returns: A code point to apply to the current packet.
  738. Uses: Method downgradeOne() and downgradeTwo().
  739. Note: See the Internet Draft, "A Single Rate Three Color Marker" (Heinanen et
  740.   al; May, 1999) for a description of the srTCM.
  741. -----------------------------------------------------------------------------*/
  742. int SRTCMPolicy::applyPolicer(policyTableEntry *policy, policerTableEntry *policer, Packet* pkt) {
  744.   hdr_cmn* hdr = hdr_cmn::access(pkt);
  745.   double size = (double) hdr->size();
  746.   
  747.   if ((policy->cBucket - size) >= 0) {
  748.     policy->cBucket -= size;
  749.     return(policer->initialCodePt);
  750.   } else {
  751.     if ((policy->eBucket - size) >= 0) {
  752.       policy->eBucket -= size;
  753.       return(policer->downgrade1);
  754.     } else
  755.       return(policer->downgrade2);
  756.   }
  757. }
  759. // End of SRTCM
  761. // Beginning of TRTCM
  762. /*----------------------------------------------------------------------------
  763. void TRTCMPolicy::applyMeter(policyTableEntry *policy, Packet *pkt)
  764. Pre: policy's variables cBucket, pBucket, cir, pir, cbs, pbs, and arrivalTime
  765.   hold valid values.
  766. Post: Increments policy's trTCM state variables cBucket and pBucket according
  767.   to the elapsed time since the last packet arrival.  cBucket is filled at a
  768.   rate equal to CIR, capped at an upper bound of CBS.  pBucket is filled at a
  769.   rate equal to PIR, capped at an upper bound of PBS.
  770.       This method also sets arrivalTime equal to the current simulator time.
  771. Note: See the Internet Draft, "A Two Rate Three Color Marker" (Heinanen et al;
  772.   May, 1999) for a description of the srTCM.
  773. ---------------------------------------------------------------------------*/
  774. void TRTCMPolicy::applyMeter(policyTableEntry *policy, Packet *pkt) {
  775.   double now = Scheduler::instance().clock();
  776.   double tokenBytes;
  777.   tokenBytes = (double) policy->cir * (now - policy->arrivalTime);
  778.   if (policy->cBucket + tokenBytes <= policy->cbs)
  779.     policy->cBucket += tokenBytes;
  780.   else
  781.     policy->cBucket = policy->cbs;
  782.   
  783.   tokenBytes = (double) policy->pir * (now - policy->arrivalTime);
  784.   if (policy->pBucket + tokenBytes <= policy->pbs)
  785.     policy->pBucket += tokenBytes;
  786.   else
  787.     policy->pBucket = policy->pbs;
  788.   
  789.   policy->arrivalTime = now;
  790. }
  792. /*----------------------------------------------------------------------------
  793. int TRTCMPolicy::applyPolicer(policyTableEntry *policy, int initialCodePt, Packet* pkt)
  794. Pre: policy points to a policyTableEntry that is using the trTCM policer and
  795.   whose state variables (cBucket and pBucket) are up to date.  pkt points to a
  796.   newly-arrived packet.
  797. Post: If policy's pBucket is smaller than pkt's size, the red code point is
  798.   retained.  Otherwise, if cBucket is smaller than the packet size, the yellow
  799.   code point is returned and pBucket is decremented.  Otherwise, the packet
  800.   remains green and both buckets are decremented.
  801. Returns: A code point to apply to the current packet.
  802. Uses: Method downgradeOne() and downgradeTwo().
  803. Note: See the Internet Draft, "A Two Rate Three Color Marker" (Heinanen et al;
  804.   May, 1999) for a description of the srTCM.
  805. -----------------------------------------------------------------------------*/
  806. int TRTCMPolicy::applyPolicer(policyTableEntry *policy, policerTableEntry *policer, Packet* pkt) {
  807.   hdr_cmn* hdr = hdr_cmn::access(pkt);
  808.   double size = (double) hdr->size();
  809.   
  810.   if ((policy->pBucket - size) < 0)
  811.     return(policer->downgrade2);
  812.   else {
  813.     if ((policy->cBucket - size) < 0) {
  814.       policy->pBucket -= size;
  815.       return(policer->downgrade1);
  816.     } else {
  817.       policy->cBucket -= size;
  818.       policy->pBucket -= size;
  819.       return(policer->initialCodePt);
  820.     }
  821.   }
  822. }
  823. // End of TRTCM
  825. // Beginning of SFD
  826. //Constructor.
  827. SFDPolicy::SFDPolicy() : Policy() {
  828.   flow_table.head = NULL;
  829.   flow_table.tail = NULL;
  830. }
  832. //Deconstructor.
  833. SFDPolicy::~SFDPolicy(){
  834.   struct flow_entry *p, *q;
  835.   p = q = flow_table.head;
  836.   while (p) {
  837.     printf("free flow: %dn", p->fid);
  838.     q = p;
  839.     p = p->next;
  840.     free(q);
  841.   }
  843.   p = q = NULL;
  844.   flow_table.head = flow_table.tail = NULL;
  845. }
  847. /*-----------------------------------------------------------------------------
  848.  void SFDPolicy::applyMeter(policyTableEntry *policy, Packet *pkt)
  849.  Flow states are kept in a linked list.
  850.  Record how many bytes has been sent per flow and check if there is any flow
  851.  timeout.
  852. -----------------------------------------------------------------------------*/
  853. void SFDPolicy::applyMeter(policyTableEntry *policy, Packet *pkt) {
  854.   int fid, src_id, dst_id;
  855.   struct flow_entry *p, *q, *new_entry;
  857.   double now = Scheduler::instance().clock();
  858.   hdr_cmn* hdr = hdr_cmn::access(pkt);
  859.   hdr_ip* iph = hdr_ip::access(pkt);
  860.   fid = iph->flowid();
  861.   dst_id = iph->daddr();
  862.   src_id = iph->saddr();
  864.   //  printf("enter applyMetern");
  865.   //  printFlowTable();
  867.   p = q = flow_table.head;
  868.   while (p) {
  869.     // Check if the flow has been recorded before.
  870.     if (p->fid == fid) {
  871.     //if (p->src_id == src_id && p->dst_id == dst_id ) {
  872.       p->last_update = now;
  873.       p->bytes_sent += hdr->size();
  874.       return;
  875.     } else if (p->last_update + FLOW_TIME_OUT < now){
  876.       // The coresponding flow is expired.      
  877.       if (p == flow_table.head){
  878. if (p == flow_table.tail) {
  879.   flow_table.head = flow_table.tail = NULL;
  880.   free(p);
  881.   p = q = NULL;
  882. } else {
  883.   flow_table.head = p->next;
  884.   free(p);
  885.   p = q = flow_table.head;
  886. }
  887.       } else {
  888. q->next = p->next;
  889. if (p == flow_table.tail)
  890.   flow_table.tail = q;
  891. free(p);
  892. p = q->next;
  893.       }
  894.     } else {
  895.       q = p;
  896.       p = q->next;
  897.     }
  898.   }
  899.   
  900.   // This is the firt time the flow shown up
  901.   if (!p) {
  902.     new_entry = new flow_entry;
  903.     new_entry->fid = fid;
  904.     new_entry->src_id = src_id;
  905.     new_entry->dst_id = dst_id;
  906.     new_entry->last_update = now;
  907.     new_entry->bytes_sent = hdr->size();
  908.     new_entry->count = 0;
  909.     new_entry->next = NULL;
  910.     
  911.     // always insert the new entry to the tail.
  912.     if (flow_table.tail)
  913.       flow_table.tail->next = new_entry;
  914.     else
  915.       flow_table.head = new_entry;
  916.     flow_table.tail = new_entry;
  917.   }
  918.   
  919.   //  printf("leave applyMetern");
  920.   return;
  921. }
  923. /*-----------------------------------------------------------------------------
  924. void SFDPolicy::applyPolicer(policyTableEntry *policy, int initialCodePt, Packet *pkt) 
  925.     Prints the policyTable, one entry per line.
  926. -----------------------------------------------------------------------------*/
  927. int SFDPolicy::applyPolicer(policyTableEntry *policy, policerTableEntry *policer, Packet *pkt) {
  928.   int fid, src_id, dst_id;
  929.   struct flow_entry *p;
  931.   hdr_ip* iph = hdr_ip::access(pkt);
  932.   fid = iph->flowid();
  933.   dst_id = iph->daddr();
  934.   src_id = iph->saddr();
  936.   //  printf("enter applyPolicern");
  937.   //printFlowTable();
  938.   
  939.   p = flow_table.head;
  940.   while (p) {
  941.     // Check if the flow has been recorded before.
  942.     if (p->fid == iph->flowid()) {
  943.       //if (p->src_id == src_id && p->dst_id == dst_id) {
  944.       if (p->bytes_sent > policy->cir) {
  945. // Use downgrade2 code to judge how to penalize out-profile packets.
  946. if (policer->downgrade2 == 0) {
  947.   // Penalize every packet beyond th.
  948.   //printf("leave applyPolicer  %d, every downgraden", p->fid);
  949.   return(policer->downgrade1);
  950. } else if (policer->downgrade2 == 1) {
  951.   // Randomized penalization.
  952.   if (Random::uniform(0.0, 1.0) > (1 - (policy->cir/p->bytes_sent))) {
  953.     //printf("leave applyPolicer %d, random initial.n", p->fid);
  954.     return(policer->initialCodePt);
  955.   } else {
  956.     //printf("leave applyPolicer %d, random, downgraden", p->fid);
  957.     return(policer->downgrade1);
  958.   }
  959. } else {
  960.   // Simple scheduling on penalization.
  961.   if (p->count == 5) {
  962.     // Penalize 4 out of every 5 packets.
  963.     p->count = 0;
  964.     //printf("leave applyPolicer %d, initial, %dn", p->fid, p->count);
  965.     return(policer->initialCodePt);
  966.   } else {
  967.     p->count++;
  968.     //printf("leave applyPolicer %d, downgrade, %dn", p->fid, p->count);
  969.     return(policer->downgrade1);
  970.   }
  971. }
  972.       } else {
  973. // printf("leave applyPolicer, initialn");
  974. return(policer->initialCodePt);
  975.       }
  976.     }
  977.     p = p->next;
  978.   }
  979.   
  980.   // Can't find the record for this flow.
  981.   if (!p) {
  982.     printf ("MISS: no flow %d (%d, %d) in the tablen", fid, src_id, dst_id);
  983.     printFlowTable();
  984. };
  985.   
  986.   //  printf("leave applyPolicer, init but problem...n");
  987.   return(policer->initialCodePt);
  988. }
  990. //    Prints the flowTable, one entry per line.
  991. void SFDPolicy::printFlowTable() {
  992.   struct flow_entry *p;
  993.   printf("Flow table:n");
  995.   p = flow_table.head;
  996.   while (p) {
  997.     printf("flow id: %d [%d %d], bytesSent: %d, last_update: %fn", 
  998.    p->fid, p->src_id, p->dst_id, p->bytes_sent, p->last_update);
  999.     p = p-> next;
  1000.   }
  1001.   p = NULL;
  1002.   printf("n");
  1003. }
  1004. // End of SFD