int main() { /************************ * PDQ global variables * ************************/ extern JOB_TYPE *job; extern double getjob_pop(); extern int getjob_index(); extern double PDQ_GetResponse(); extern double PDQ_GetThruput(); extern double PDQ_GetUtilization(); /**************************** * Model specific variables * ****************************/ int noNodes; int noStreams; int tech; int pop; double think = 0.0; /************************ * Initialize the model * ************************/ /* Give model a name */ /*PDQ_Init("Test_Exact_Calc");*/ tech = APPROX; printf("**** %s Solution ****:\n\n", tech == EXACT ? "EXACT" : "APPROX"); printf(" N R (w1) R (w2)\n"); for (pop = 1; pop < 10; pop++) { PDQ_Init("Test_Exact_calc"); /* Define the workload and circuit type */ noStreams = PDQ_CreateClosed("w1", TERM, 1.0 * pop, think); noStreams = PDQ_CreateClosed("w2", TERM, 1.0 * pop, think); /* Define the queueing center */ noNodes = PDQ_CreateNode("node", CEN, FCFS); /* Define service demand */ PDQ_SetDemand("node", "w1", 1.0); PDQ_SetDemand("node", "w2", 0.5); /******************* * Solve the model * *******************/ PDQ_Solve(tech); /* printf("N\tR\n%8.4f %8.4f\n", getjob_pop(getjob_index("w1")), PDQ_GetResponse(TERM, "w1")); printf("N\tR\n%8.4f %8.4f\n", getjob_pop(getjob_index("w2")), PDQ_GetResponse(TERM, "w2")); */ printf("%3d %8.4f %8.4f\n", pop, PDQ_GetResponse(TERM, "w1"), PDQ_GetResponse(TERM, "w2")); } return(0); } // main
int main(void) { extern int nodes, streams; extern JOB_TYPE *job; extern NODE_TYPE *node; extern char s1[]; char transCD[MAXCHARS], transRQ[MAXCHARS], transSU[MAXCHARS]; char dummyCD[MAXCHARS], dummyRQ[MAXCHARS], dummySU[MAXCHARS]; char nodePC[MAXCHARS], nodeFS[MAXCHARS], nodeGW[MAXCHARS]; char nodeMF[MAXCHARS], nodeTR[MAXCHARS]; double demand[MAXPROC][MAXDEV], util[MAXDEV], udsk[MAXDEV], udasd[MAXDEV], RTexpect[MAXPROC]; double fsd, RTmean, ulan, ufs, uws, ugw, umf; int work, dev, i, j; /* Disk-array data structures probably should go into PDQ_Build.c one day. */ devarray_type *FDarray; devarray_type *MDarray; if ((FDarray = (devarray_type *) calloc(sizeof(devarray_type), 10)) == NULL) errmsg("", "FDarray allocation failed!\n"); if ((MDarray = (devarray_type *) calloc(sizeof(devarray_type), 10)) == NULL) errmsg("", "MDarray allocation failed!\n"); for (i = 0; i < FS_DISKS; i++) { FDarray[i].id = FD + i; resets(s1); sprintf(s1, "FSDK%d", i); strcpy(FDarray[i].label, s1); } for (i = 0; i < MF_DISKS; i++) { MDarray[i].id = MD + i; resets(s1); sprintf(s1, "MFDK%d", i); strcpy(MDarray[i].label, s1); } /* CPU service times are calculated from instruction counts tabulated in original 1993 CMG paper. */ demand[CD_Req][PC] = 200 * k / PC_MIPS; demand[CD_Rpy][PC] = 100 * k / PC_MIPS; demand[RQ_Req][PC] = 150 * k / PC_MIPS; demand[RQ_Rpy][PC] = 200 * k / PC_MIPS; demand[SU_Req][PC] = 300 * k / PC_MIPS; demand[SU_Rpy][PC] = 300 * k / PC_MIPS; demand[Req_CD][FS] = 50 * k / FS_MIPS; demand[Req_RQ][FS] = 70 * k / FS_MIPS; demand[Req_SU][FS] = 10 * k / FS_MIPS; demand[CD_Msg][FS] = 35 * k / FS_MIPS; demand[RQ_Msg][FS] = 35 * k / FS_MIPS; demand[SU_Msg][FS] = 35 * k / FS_MIPS; demand[GT_Snd][GW] = 50 * k / GW_MIPS; demand[GT_Rcv][GW] = 50 * k / GW_MIPS; demand[MF_CD][MF] = 50 * k / MF_MIPS; demand[MF_RQ][MF] = 150 * k / MF_MIPS; demand[MF_SU][MF] = 20 * k / MF_MIPS; /* Service time on the LAN to send and recv packets from any of the PC desktop, the file server or the SNA gateway. 8 bits per Byte. */ demand[LAN_TX][PC] = (double) TR_Bytes * 8 / TR_Mbps; demand[LAN_TX][FS] = (double) TR_Bytes * 8 / TR_Mbps; demand[LAN_TX][GW] = (double) TR_Bytes * 8 / TR_Mbps; /* * File server disk IOs = number of accesses x caching / (max IOs / Sec) */ for (i = 0; i < FS_DISKS; i++) { demand[Req_CD][FDarray[i].id] = (1.0 * 0.5 / 128.9) / FS_DISKS; demand[Req_RQ][FDarray[i].id] = (1.5 * 0.5 / 128.9) / FS_DISKS; demand[Req_SU][FDarray[i].id] = (0.2 * 0.5 / 128.9) / FS_DISKS; demand[CD_Msg][FDarray[i].id] = (1.0 * 0.5 / 128.9) / FS_DISKS; demand[RQ_Msg][FDarray[i].id] = (1.5 * 0.5 / 128.9) / FS_DISKS; demand[SU_Msg][FDarray[i].id] = (0.5 * 0.5 / 128.9) / FS_DISKS; } /* Mainframe DASD IOs = (#accesses / (max IOs/Sec)) / #disks */ for (i = 0; i < MF_DISKS; i++) { demand[MF_CD][MDarray[i].id] = (2.0 / 60.24) / MF_DISKS; demand[MF_RQ][MDarray[i].id] = (4.0 / 60.24) / MF_DISKS; demand[MF_SU][MDarray[i].id] = (1.0 / 60.24) / MF_DISKS; } /* Now, start building the PDQ model... */ PDQ_Init(scenario); /* Define physical resources as PDQ queueing nodes. */ strcpy(nodePC, "PCDESK"); strcpy(nodeFS, "FSERVR"); strcpy(nodeGW, "GATWAY"); strcpy(nodeMF, "MFRAME"); strcpy(nodeTR, "TRLAN"); PDQ_CreateNode(nodePC, CEN, FCFS); PDQ_CreateNode(nodeFS, CEN, FCFS); PDQ_CreateNode(nodeGW, CEN, FCFS); PDQ_CreateNode(nodeMF, CEN, FCFS); for (i = 0; i < FS_DISKS; i++) { PDQ_CreateNode(FDarray[i].label, CEN, FCFS); } for (i = 0; i < MF_DISKS; i++) { PDQ_CreateNode(MDarray[i].label, CEN, FCFS); } /* * NOTE: Although the token ring LAN is a passive computational device, it * is treated as a separate node so as to agree with the results presented * in the original CMG 1993 paper. */ PDQ_CreateNode(nodeTR, CEN, FCFS); /* * Because the desktop PCs are all of the same type and emitting the same * homogeneous transaction workload, the focus can be placed on the * response time performance of a single PC workstation and generalized to * the others. Rather than having N * 3 workload streams or classes, we * simply model 2 PC desktops: the "real" one of interest and a dummy PC * representing the remaining (N-1) * 3 streams. */ strcpy(transCD, "CatDisplay"); strcpy(transRQ, "RemotQuote"); strcpy(transSU, "StatUpdate"); /* Aggregate transactions */ strcpy(dummyCD, "CatDispAgg"); strcpy(dummyRQ, "RemQuotAgg"); strcpy(dummySU, "StatUpdAgg"); PDQ_CreateOpen(transCD, 1 * 4.0 * TPS); PDQ_CreateOpen(transRQ, 1 * 8.0 * TPS); PDQ_CreateOpen(transSU, 1 * 1.0 * TPS); PDQ_CreateOpen(dummyCD, (USERS - 1) * 4.0 * TPS); PDQ_CreateOpen(dummyRQ, (USERS - 1) * 8.0 * TPS); PDQ_CreateOpen(dummySU, (USERS - 1) * 1.0 * TPS); /* Define the service demands on each physical resource. CD request + reply chain from workflow diagram Note that only the "real" PC demand is defined, and the aggregated (N-1) PCs. */ /******************* RQ request + reply chain ... *******************/ PDQ_SetDemand(nodePC, transCD, demand[CD_Req][PC] + (5 * demand[CD_Rpy][PC])); PDQ_SetDemand(nodeFS, transCD, demand[Req_CD][FS] + (5 * demand[CD_Msg][FS])); PDQ_SetDemand(nodeFS, dummyCD, demand[Req_CD][FS] + (5 * demand[CD_Msg][FS])); PDQ_SetDemand(nodeGW, transCD, demand[GT_Snd][GW] + (5 * demand[GT_Rcv][GW])); PDQ_SetDemand(nodeGW, dummyCD, demand[GT_Snd][GW] + (5 * demand[GT_Rcv][GW])); PDQ_SetDemand(nodeMF, transCD, demand[MF_CD][MF]); PDQ_SetDemand(nodeMF, dummyCD, demand[MF_CD][MF]); for (i = 0; i < FS_DISKS; i++) { fsd = demand[Req_CD][FDarray[i].id] + (5 * demand[CD_Msg][FDarray[i].id]); PDQ_SetDemand(FDarray[i].label, transCD, fsd); PDQ_SetDemand(FDarray[i].label, dummyCD, fsd); } for (i = 0; i < MF_DISKS; i++) { PDQ_SetDemand(MDarray[i].label, transCD, demand[MF_CD][MDarray[i].id]); PDQ_SetDemand(MDarray[i].label, dummyCD, demand[MF_CD][MDarray[i].id]); } /* NOTE:Synchronous process execution causes data for the CD transaction to cross the LAN 12 times as depicted in the following parameterization of PDQ_SetDemand. */ PDQ_SetDemand(nodeTR, transCD, (1 * demand[LAN_TX][PC]) + (1 * demand[LAN_TX][FS]) + (1 * demand[LAN_TX][GW]) + (5 * demand[LAN_TX][GW]) + (5 * demand[LAN_TX][FS]) + (5 * demand[LAN_TX][PC])); PDQ_SetDemand(nodeTR, dummyCD, (1 * demand[LAN_TX][PC]) + (1 * demand[LAN_TX][FS]) + (1 * demand[LAN_TX][GW]) + (5 * demand[LAN_TX][GW]) + (5 * demand[LAN_TX][FS]) + (5 * demand[LAN_TX][PC])); /******************* RQ request + reply chain ... *******************/ PDQ_SetDemand(nodePC, transRQ, demand[RQ_Req][PC] + (3 * demand[RQ_Rpy][PC])); PDQ_SetDemand(nodeFS, transRQ, demand[Req_RQ][FS] + (3 * demand[RQ_Msg][FS])); PDQ_SetDemand(nodeFS, dummyRQ, demand[Req_RQ][FS] + (3 * demand[RQ_Msg][FS])); for (i = 0; i < FS_DISKS; i++) { PDQ_SetDemand(FDarray[i].label, transRQ, demand[Req_RQ][FDarray[i].id] + (3 * demand[RQ_Msg][FDarray[i].id])); PDQ_SetDemand(FDarray[i].label, dummyRQ, demand[Req_RQ][FDarray[i].id] + (3 * demand[RQ_Msg][FDarray[i].id])); } PDQ_SetDemand(nodeGW, transRQ, demand[GT_Snd][GW] + (3 * demand[GT_Rcv][GW])); PDQ_SetDemand(nodeGW, dummyRQ, demand[GT_Snd][GW] + (3 * demand[GT_Rcv][GW])); PDQ_SetDemand(nodeMF, transRQ, demand[MF_RQ][MF]); PDQ_SetDemand(nodeMF, dummyRQ, demand[MF_RQ][MF]); for (i = 0; i < MF_DISKS; i++) { PDQ_SetDemand(MDarray[i].label, transRQ, demand[MF_RQ][MDarray[i].id]); PDQ_SetDemand(MDarray[i].label, dummyRQ, demand[MF_RQ][MDarray[i].id]); } PDQ_SetDemand(nodeTR, transRQ, (1 * demand[LAN_TX][PC]) + (1 * demand[LAN_TX][FS]) + (1 * demand[LAN_TX][GW]) + (3 * demand[LAN_TX][GW]) + (3 * demand[LAN_TX][FS]) + (3 * demand[LAN_TX][PC])); PDQ_SetDemand(nodeTR, dummyRQ, (1 * demand[LAN_TX][PC]) + (1 * demand[LAN_TX][FS]) + (1 * demand[LAN_TX][GW]) + (3 * demand[LAN_TX][GW]) + (3 * demand[LAN_TX][FS]) + (3 * demand[LAN_TX][PC])); /******************* SU request + reply chain *******************/ PDQ_SetDemand(nodePC, transSU, demand[SU_Req][PC] + demand[SU_Rpy][PC]); PDQ_SetDemand(nodeFS, transSU, demand[Req_SU][FS] + demand[SU_Msg][FS]); PDQ_SetDemand(nodeFS, dummySU, demand[Req_SU][FS] + demand[SU_Msg][FS]); for (i = 0; i < FS_DISKS; i++) { PDQ_SetDemand(FDarray[i].label, transSU, demand[Req_SU][FDarray[i].id] + demand[SU_Msg][FDarray[i].id]); PDQ_SetDemand(FDarray[i].label, dummySU, demand[Req_SU][FDarray[i].id] + demand[SU_Msg][FDarray[i].id]); } PDQ_SetDemand(nodeGW, transSU, demand[GT_Snd][GW] + demand[GT_Rcv][GW]); PDQ_SetDemand(nodeGW, dummySU, demand[GT_Snd][GW] + demand[GT_Rcv][GW]); PDQ_SetDemand(nodeMF, transSU, demand[MF_SU][MF]); PDQ_SetDemand(nodeMF, dummySU, demand[MF_SU][MF]); for (i = 0; i < MF_DISKS; i++) { PDQ_SetDemand(MDarray[i].label, transSU, demand[MF_SU][MDarray[i].id]); PDQ_SetDemand(MDarray[i].label, dummySU, demand[MF_SU][MDarray[i].id]); } PDQ_SetDemand(nodeTR, transSU, (1 * demand[LAN_TX][PC]) + (1 * demand[LAN_TX][FS]) + (1 * demand[LAN_TX][GW]) + (1 * demand[LAN_TX][GW]) + (1 * demand[LAN_TX][FS]) + (1 * demand[LAN_TX][PC])); PDQ_SetDemand(nodeTR, dummySU, (1 * demand[LAN_TX][PC]) + (1 * demand[LAN_TX][FS]) + (1 * demand[LAN_TX][GW]) + (1 * demand[LAN_TX][GW]) + (1 * demand[LAN_TX][FS]) + (1 * demand[LAN_TX][PC])); PDQ_SetDebug(FALSE); PDQ_SetWUnit("Trans"); PDQ_Solve(CANON); if (PRINT_REPORT) { PDQ_Report(); } /* Break out each tx response time together with resource utilizations. The order of print out is the same as the 1993 CMG paper. */ /* Mean response times reported in the CMG93 paper */ RTexpect[0] = 0.2754; RTexpect[1] = 0.2625; RTexpect[2] = 0.1252; RTexpect[3] = 0.2624; RTexpect[4] = 0.2470; RTexpect[5] = 0.1120; printf("*** Metric breakout for \"%s\" with %d clients ***\n\n", scenario, USERS); printf("Transaction\t R (Sec)\t CMG paper\n"); printf("-----------\t -------\t ---------\n"); for (work = 0; work < streams; work++) { resets(s1); strcpy(s1, job[work].trans->name); RTmean = PDQ_GetResponse(TRANS, s1); printf("%-15s\t%10.4f\t%10.4f\n", s1, RTmean, RTexpect[work]); } printf("\n\n"); /* * Get node utilizations. This is a bit of a hack and should be written as * a subroutine. */ for (dev = 0; dev < nodes; dev++) { util[dev] = 0.0; /* reset array */ for (work = 0; work < streams; work++) { util[dev] += 100 * PDQ_GetUtilization(node[dev].devname, job[work].trans->name, TRANS); } } for (dev = 0; dev < nodes; dev++) { for (i = 0; i < MF_DISKS; i++) { if (strcmp(node[dev].devname, MDarray[i].label) == 0) { udasd[i] = util[dev]; } } for (i = 0; i < FS_DISKS; i++) { if (strcmp(node[dev].devname, FDarray[i].label) == 0) { udsk[i] = util[dev]; } } if (strcmp(node[dev].devname, nodePC) == 0) { uws = util[dev]; } if (strcmp(node[dev].devname, nodeGW) == 0) { ugw = util[dev]; } if (strcmp(node[dev].devname, nodeFS) == 0) { ufs = util[dev]; } if (strcmp(node[dev].devname, nodeMF) == 0) { umf = util[dev]; } if (strcmp(node[dev].devname, nodeTR) == 0) { ulan = util[dev]; } } printf("PDQ Node \t %% Busy\t CMG paper\n"); printf("-------- \t -------\t ---------\n"); printf("%-15s\t%10.4f\t%10.4f\n", "Token ring", ulan, 49.3333); printf("%-15s\t%10.4f\t%10.4f\n", "PC Desktop", uws, 0.5802); printf("%-15s\t%10.4f\t%10.4f\n", "File server", ufs, 11.9157); printf("%-15s\t%10.4f\t%10.4f\n", "Gateway CPU", ugw, 60.4167); printf("%-15s\t%10.4f\t%10.4f\n", "Mainframe", umf, 14.0873); for (i = 0; i < FS_DISKS; i++) { printf("%s%d\t%10.4f\t%10.4f\n", "FS disks", FDarray[i].id, udsk[i], 59.0028); } for (i = 0; i < MF_DISKS; i++) { printf("%s%d\t%10.4f\t%10.4f\n", "DASD disk", MDarray[i].id, udasd[i], 35.5502); } } /* main */
int main() { extern JOB_TYPE *job; extern double getjob_pop(); extern int getjob_index(); extern double PDQ_GetResponse(); extern double PDQ_GetThruput(); extern double PDQ_GetUtilization(); /**************************** * Model specific variables * ****************************/ int noNodes; int noStreams; int pop, servers = 2; int s, w; #define STRESS 0 #define HOMEPG 1 static char *work[] = { "stress", "homepg" }; static double time[] = { 0.0044, /* stress */ 0.0300 /* homepg */ }; static char *slave[] = { "slave0", "slave1", "slave2", "slave3", "slave4", "slave5", "slave6", "slave7", "slave8", "slave9", "slave10", "slave11", "slave12", "slave13", "slave14", "slave15" }; #define PREFORK w = HOMEPG; #ifdef PREFORK printf("Pre-Fork Model under \"%s\" Load (m = %d)\n", w == STRESS ? work[STRESS] : work[HOMEPG], servers); #else printf("Forking Model under \"%s\" Load \n", w == STRESS ? work[STRESS] : work[HOMEPG]); #endif printf("\n N X R\n"); for (pop = 1; pop <= 10; pop++) { PDQ_Init("HTTPd_Server"); noStreams = PDQ_CreateClosed(work[w], TERM, 1.0 * pop, 0.0); noNodes = PDQ_CreateNode("master", CEN, FCFS); #ifdef PREFORK for (s = 0; s < servers; s++) { noNodes = PDQ_CreateNode(slave[s], CEN, FCFS); } PDQ_SetDemand("master", work[w], 0.0109); for (s = 0; s < servers; s++) { PDQ_SetDemand(slave[s], work[w], time[w] / servers); } #else /* FORKING */ noNodes = PDQ_CreateNode("forks", CEN, ISRV); PDQ_SetDemand("master", work[w], 0.0165); PDQ_SetDemand("forks", work[w], time[w]); #endif PDQ_Solve(EXACT); printf("%5.2f %8.4f %8.4f\n", getjob_pop(getjob_index(work[w])), PDQ_GetThruput(TERM, work[w]), PDQ_GetResponse(TERM, work[w])); } return(0); } // main
main() { extern int nodes, streams; int i; char name[30]; int broj_ap_posluzitelja = BROJ_AP_POSLUZITELJA; int broj_bp_posluzitelja = BROJ_BP_POSLUZITELJA; int broj_im_posluzitelja = BROJ_IM_POSLUZITELJA; float L = 0.5; float p_im = 0.0; float S_ZZ = 0.001; float S_PO = 0.001; float S_AP = 0.3; float S_BP = 4.5; float S_IM = 0.5; float Util = 0.0; float Res = 0.0; float p_bp = 0.0; float p_bp_inc = 0.05; float p_bp_max = 0.5; printf("p"); for( i=0; i<broj_ap_posluzitelja; i++ ) { sprintf(name, "R_AP%d", i); printf("\t%s", name); } for( i=0; i<broj_bp_posluzitelja; i++ ) { sprintf(name, "R_BP%d", i); printf("\t%s", name); } for( i=0; i<broj_im_posluzitelja; i++ ) { sprintf(name, "R_IM%d", i); printf("\t%s", name); } printf("\tR_ZZ"); printf("\tR_PO"); printf("\tAP_R\n"); p_bp = p_bp_inc; while (p_bp < p_bp_max + p_bp_inc) { PDQ_Init("Web aplikacija"); streams = PDQ_CreateOpen("Zahtjevi", L); nodes = PDQ_CreateNode("ZZ", CEN, FCFS); nodes = PDQ_CreateNode("PO", CEN, FCFS); for( i=0; i<broj_ap_posluzitelja; i++ ) { sprintf(name, "AP%d", i); nodes = PDQ_CreateNode(name, CEN, FCFS); } for( i=0; i<broj_bp_posluzitelja; i++ ) { sprintf(name, "BP%d", i); nodes = PDQ_CreateNode(name, CEN, FCFS); } for( i=0; i<broj_im_posluzitelja; i++ ) { sprintf(name, "IM%d", i); nodes = PDQ_CreateNode(name, CEN, FCFS); } PDQ_SetVisits("ZZ", "Zahtjevi", 1.0, S_ZZ); PDQ_SetVisits("PO", "Zahtjevi", 1.0, S_PO); for( i=0; i<broj_ap_posluzitelja; i++ ) { sprintf(name, "AP%d", i); PDQ_SetVisits(name, "Zahtjevi", ((1 - p_im) / (1 - p_bp)) / BROJ_AP_POSLUZITELJA, S_AP); } for( i=0; i<broj_bp_posluzitelja; i++ ) { sprintf(name, "BP%d", i); PDQ_SetVisits(name, "Zahtjevi", (p_bp * (1 - p_im) / (1 - p_bp)) / BROJ_BP_POSLUZITELJA, S_BP); } for( i=0; i<broj_im_posluzitelja; i++ ) { sprintf(name, "IM%d", i); PDQ_SetVisits(name, "Zahtjevi", p_im / BROJ_IM_POSLUZITELJA, S_IM); } PDQ_Solve(CANON); Util = 0.0; for( i=0; i<broj_ap_posluzitelja; i++ ) { sprintf(name, "AP%d", i); Util += PDQ_GetUtilization(name, "Zahtjevi", TRANS); } for( i=0; i<broj_bp_posluzitelja; i++ ) { sprintf(name, "BP%d", i); Util += PDQ_GetUtilization(name, "Zahtjevi", TRANS); } for( i=0; i<broj_im_posluzitelja; i++ ) { sprintf(name, "IM%d", i); Util += PDQ_GetUtilization(name, "Zahtjevi", TRANS); } Util += PDQ_GetUtilization("ZZ", "Zahtjevi", TRANS); Util += PDQ_GetUtilization("PO", "Zahtjevi", TRANS); Util = (100 * Util)/(broj_ap_posluzitelja + broj_bp_posluzitelja + broj_im_posluzitelja + 2); printf("%f\t", p_bp); for( i=0; i<broj_ap_posluzitelja; i++ ) { sprintf(name, "AP%d", i); printf("%f\t", PDQ_GetResidenceTime(name, "Zahtjevi", TRANS)); } for( i=0; i<broj_bp_posluzitelja; i++ ) { sprintf(name, "BP%d", i); printf("%f\t", PDQ_GetResidenceTime(name, "Zahtjevi", TRANS)); } for( i=0; i<broj_im_posluzitelja; i++ ) { sprintf(name, "IM%d", i); printf("%f\t", PDQ_GetResidenceTime(name, "Zahtjevi", TRANS)); } printf("%f\t", PDQ_GetResidenceTime(name, "ZZ", TRANS)); printf("%f\t", PDQ_GetResidenceTime(name, "PO", TRANS)); printf("%f\n", PDQ_GetResponse(TRANS, "Zahtjevi")); p_bp += p_bp_inc; } }