1889 -		user_parm->inline_size = 0;

  1890 -

  1891 -	printf(" Inline data is used up to %d bytes message\n", user_parm->inline_size);

  1892 -

  1893 -	ctx->size = user_parm->size;

  1894 -

  1895 -	// Finds the link type and configure the HCA accordingly.

  1896 -	if (ctx_set_link_layer(ctx->context,user_parm)) {

  1897 -		fprintf(stderr, " Couldn't set the link layer\n");

  1898 -		return NULL;

  1899 -	}

  1900 -	

  1901 -	if (user_parm->use_event) {

  1902 -		ctx->channel = ibv_create_comp_channel(ctx->context);

  1903 -		if (!ctx->channel) {

  1904 -			fprintf(stderr, "Couldn't create completion channel\n");

  1905 -			return NULL;

  1906 -		}

  1907 -	} else

  1908 -		ctx->channel = NULL;                  

  1909 -

  1910 -	ctx->pd = ibv_alloc_pd(ctx->context);

  1911 -	if (!ctx->pd) {

  1912 -		fprintf(stderr, "Couldn't allocate PD\n");

  1913 -		return NULL;

  1914 -	}

  1915 -

  1916 -	for (i = 0; i < user_parm->num_of_qps; i++) {

  1917 -

  1918 -		m_size = (BUFF_SIZE(user_parm->size) + IF_UD_ADD(user_parm->connection_type))*duplex_ind;

  1919 -		ctx->buf[i] = memalign(page_size,m_size);

  1920 -		if (!ctx->buf[i]) {

  1921 -			fprintf(stderr, "Couldn't allocate work buf.\n");

  1922 -			return NULL;

  1923 -		}

  1924 -		memset(ctx->buf[i],0,m_size);

  1925 -

  1926 -		// We dont really want IBV_ACCESS_LOCAL_WRITE, but IB spec says :

  1927 -		// The Consumer is not allowed to assign Remote Write or Remote Atomic to

  1928 -		// a Memory Region that has not been assigned Local Write. 

  1929 -		ctx->mr[i] = ibv_reg_mr(ctx->pd,

  1930 -								ctx->buf[i],

  1931 -								m_size,

  1932 -								IBV_ACCESS_REMOTE_WRITE | 

  1933 -								IBV_ACCESS_LOCAL_WRITE);

  1934 -

  1935 -		if (!ctx->mr[i]) {

  1936 -			fprintf(stderr, "Couldn't allocate MR\n");

  1937 -			return NULL;

  1938 -		}

  1939 -	}

  1940 -

  1941 -	// Create the CQ according to Client/Server or Duplex setting.

  1942 -	ctx->cq = ctx_cq_create(ctx->context,ctx->channel,user_parm);

  1943 -	if (ctx->cq == NULL) {

  1944 -		fprintf(stderr, "Couldn't create CQ \n");

  1945 -		return NULL;

  1946 -	}

  1947 -

  1948 -	ALLOCATE(ctx->qp,struct ibv_qp*,user_parm->num_of_qps);

  1949 -	

  1950 -	for(i=0; i < user_parm->num_of_qps; i++) {

  1951 -		ctx->qp[i] = ctx_qp_create(ctx->pd,ctx->cq,ctx->cq,user_parm);

  1952 -		if (ctx->qp[i] == NULL) {

  1953 -			return NULL;

  1954 -		}

  1955 -

  1956 -		if(ctx_modify_qp_to_init(ctx->qp[i],user_parm)) {

  1957 -			return NULL;

  1958 -		}

  1959 -	}

  1960 -

  1961 -	return ctx;

  1962 -}

  1963 -

  1964 -/****************************************************************************** 

  1965 - *

  1966 - ******************************************************************************/

  1967 -static int pp_connect_ctx(struct pingpong_context *ctx,int my_psn,

  1968 -			              struct pingpong_dest *dest, 

  1969 -						  struct perftest_parameters *user_parm)

  1970 -{

  1971 -	struct ibv_qp_attr attr;

  1972 -	memset(&attr, 0, sizeof attr);

  1973 -	int i;

  1974 -

  1975 -	attr.qp_state 		= IBV_QPS_RTR;

  1976 -	attr.path_mtu       = user_parm->curr_mtu;

  1977 -    attr.dest_qp_num    = dest->qpn;

  1978 -	attr.rq_psn         = dest->psn;

  1979 -	attr.ah_attr.dlid   = dest->lid;

  1980 -	if (user_parm->connection_type == RC) {

  1981 -		attr.max_dest_rd_atomic     = 1;

  1982 -		attr.min_rnr_timer          = 12;

  1983 -	}

  1984 -	if (user_parm->gid_index < 0) {

  1985 -		attr.ah_attr.is_global  = 0;

  1986 -		attr.ah_attr.sl         = user_parm->sl;

  1987 -	} else {

  1988 -		attr.ah_attr.is_global  = 1;

  1989 -		attr.ah_attr.grh.dgid   = dest->gid;

  1990 -		attr.ah_attr.grh.sgid_index = user_parm->gid_index;

  1991 -		attr.ah_attr.grh.hop_limit = 1;

  1992 -		attr.ah_attr.sl         = 0;

  1993 -	}

  1994 -	attr.ah_attr.src_path_bits = 0;

  1995 -	attr.ah_attr.port_num   = user_parm->ib_port;

  1996 -	

  1997 -	if (user_parm->connection_type == RC) {

  1998 -		if (ibv_modify_qp(ctx->qp[0], &attr,

  1999 -				  IBV_QP_STATE              |

  2000 -				  IBV_QP_AV                 |

  2001 -				  IBV_QP_PATH_MTU           |

  2002 -				  IBV_QP_DEST_QPN           |

  2003 -				  IBV_QP_RQ_PSN             |

  2004 -				  IBV_QP_MIN_RNR_TIMER      |

  2005 -				  IBV_QP_MAX_DEST_RD_ATOMIC)) {

  2006 -			fprintf(stderr, "Failed to modify RC QP to RTR\n");

  2007 -			return 1;

  2008 -		}

  2009 -		attr.timeout            = user_parm->qp_timeout;

  2010 -		attr.retry_cnt          = 7;

  2011 -		attr.rnr_retry          = 7;

  2012 -	} else if (user_parm->connection_type == UC) {

  2013 -		if (ibv_modify_qp(ctx->qp[0], &attr,

  2014 -				  IBV_QP_STATE              |

  2015 -				  IBV_QP_AV                 |

  2016 -				  IBV_QP_PATH_MTU           |

  2017 -				  IBV_QP_DEST_QPN           |

  2018 -				  IBV_QP_RQ_PSN)) {

  2019 -			fprintf(stderr, "Failed to modify UC QP to RTR\n");

  2020 -			return 1;

  2021 -		}

  2022 -	} 

  2023 -	 

  2024 -	else {

  2025 -		for (i = 0; i < user_parm->num_of_qps; i++) {

  2026 -			if (ibv_modify_qp(ctx->qp[i],&attr,IBV_QP_STATE )) {

  2027 -				fprintf(stderr, "Failed to modify UD QP to RTR\n");

  2028 -				return 1;

  2029 -			}

  2030 -		}

  2031 -		if (user_parm->machine == CLIENT || user_parm->duplex) {

  2032 -			ctx->ah = ibv_create_ah(ctx->pd,&attr.ah_attr);

  2033 -			if (!ctx->ah) {

  2034 -				fprintf(stderr, "Failed to create AH for UD\n");

  2035 -				return 1;

  2036 -			}

  2037 -		}

  2038 -	}

  2039 -

  2040 -	if (user_parm->machine == CLIENT || user_parm->duplex) {

  2041 -

  2042 -		attr.qp_state 	    = IBV_QPS_RTS;

  2043 -		attr.sq_psn 	    = my_psn;

  2044 -		if (user_parm->connection_type == RC) {

  2045 -			attr.max_rd_atomic  = 1;

  2046 -			if (ibv_modify_qp(ctx->qp[0], &attr,

  2047 -					IBV_QP_STATE              |

  2048 -					IBV_QP_SQ_PSN             |

  2049 -					IBV_QP_TIMEOUT            |

  2050 -					IBV_QP_RETRY_CNT          |

  2051 -					IBV_QP_RNR_RETRY          |

  2052 -					IBV_QP_MAX_QP_RD_ATOMIC)) {

  2053 -				fprintf(stderr, "Failed to modify RC QP to RTS\n");

  2054 -				return 1;

  2055 -			}

  2056 -

  2057 -		} else {

  2058 -			if(ibv_modify_qp(ctx->qp[0],&attr,IBV_QP_STATE |IBV_QP_SQ_PSN)) {

  2059 -				fprintf(stderr, "Failed to modify UC QP to RTS\n");

  2060 -				return 1;

  2061 -			}

  2062 -		}

  2063 -	}

  2064 -

  2065 -	return 0;

  2066 -}

  2067 -

  2068 -/****************************************************************************** 

  2069 - *

  2070 - ******************************************************************************/

  2071 -static int set_recv_wqes(struct pingpong_context *ctx,

  2072 -						 struct perftest_parameters *user_param) {

  2073 -						

  2074 -	int					i,j,buff_size;

  2075 -	int 				duplex_ind;

  2076 -	struct ibv_recv_wr  *bad_wr_recv;

  2077 -

  2078 -	i = (user_param->duplex && user_param->use_mcg) ? 1 : 0;

  2079 -	duplex_ind = (user_param->duplex && !user_param->use_mcg) ? 1 : 0;

  2080 -

  2081 -	buff_size = BUFF_SIZE(ctx->size) + IF_UD_ADD(user_param->connection_type);

  2082 -

  2083 -	while (i < user_param->num_of_qps) {

  2084 -

  2085 -		ctx->sge_list[i].addr   = (uintptr_t)ctx->buf[i] + duplex_ind*buff_size;

  2086 -

  2087 -		if (user_param->connection_type == UD) 

  2088 -			ctx->sge_list[i].addr += (CACHE_LINE_SIZE - UD_ADDITION);

  2089 -

  2090 -		ctx->sge_list[i].length = SIZE(user_param->connection_type,user_param->size);

  2091 -		ctx->sge_list[i].lkey   = ctx->mr[i]->lkey;

  2092 -		ctx->rwr[i].sg_list     = &ctx->sge_list[i];

  2093 -		ctx->rwr[i].wr_id       = i;

  2094 -		ctx->rwr[i].next        = NULL;

  2095 -		ctx->rwr[i].num_sge	    = MAX_RECV_SGE;

  2096 -		ctx->my_addr[i]		    = (uintptr_t)ctx->buf[i] + duplex_ind*buff_size;

  2097 -		

  2098 -		for (j = 0; j < user_param->rx_depth; ++j) {

  2099 -

  2100 -			if (ibv_post_recv(ctx->qp[i],&ctx->rwr[i],&bad_wr_recv)) {

  2101 -				fprintf(stderr, "Couldn't post recv Qp = %d: counter=%d\n",i,j);

  2102 -				return 1;

  2103 -			}

  2104 -

  2105 -			if (user_param->size <= (CYCLE_BUFFER / 2))

  2106 -				increase_loc_addr(&ctx->sge_list[i],user_param->size,j,ctx->my_addr[i],user_param->connection_type);

  2107 -		}

  2108 -		i++;

  2109 -	}

  2110 -	return 0;

  2111 -}

  2112 -

  2113 -/****************************************************************************** 

  2114 - *

  2115 - ******************************************************************************/

  2116 -static void set_send_wqe(struct pingpong_context *ctx,int rem_qpn,

  2117 -						 struct perftest_parameters *user_param) {

  2118 -

  2119 -	ctx->list.addr     = (uintptr_t)ctx->buf[0];

  2120 -	ctx->list.lkey 	   = ctx->mr[0]->lkey;

  2121 -

  2122 -	ctx->wr.sg_list    = &ctx->list;

  2123 -	ctx->wr.num_sge    = 1;

  2124 -	ctx->wr.opcode     = IBV_WR_SEND;

  2125 -	ctx->wr.next       = NULL;

  2126 -	ctx->wr.wr_id      = PINGPONG_SEND_WRID;

  2127 -	ctx->wr.send_flags = IBV_SEND_SIGNALED;

  2128 -

  2129 -	if (user_param->connection_type == UD) {

  2130 -		ctx->wr.wr.ud.ah          = ctx->ah;

  2131 -		ctx->wr.wr.ud.remote_qkey = DEF_QKEY;

  2132 -		ctx->wr.wr.ud.remote_qpn  = rem_qpn;

  2133 -	}

  2134 -}

  2135 -

  2136 -/****************************************************************************** 

  2137 - *

  2138 - ******************************************************************************/

  2139 -static int pp_drain_qp(struct pingpong_context *ctx,

  2140 -						struct perftest_parameters *user_param,

  2141 -						int psn,struct pingpong_dest *dest,

  2142 -						struct mcast_parameters *mcg_params) {

  2143 -

  2144 -	struct ibv_qp_attr attr;

  2145 -	struct ibv_wc      wc;

  2146 -	int                i;

  2147 -

  2148 -	memset(&attr, 0, sizeof attr);

  2149 -	attr.qp_state = IBV_QPS_ERR;

  2150 -

  2151 -	for (i = 0; i <  user_param->num_of_qps; i++) {

  2152 -

  2153 -		if (ibv_modify_qp(ctx->qp[i],&attr,IBV_QP_STATE)) {

  2154 -			fprintf(stderr, "Failed to modify RC QP to ERR\n");

  2155 -			return 1;

  2156 -		}

  2157 -

  2158 -		while (ibv_poll_cq(ctx->cq,1,&wc));

  2159 -   

  2160 -		attr.qp_state = IBV_QPS_RESET;

  2161 -

  2162 -		if (ibv_modify_qp(ctx->qp[i],&attr,IBV_QP_STATE)) {

  2163 -			fprintf(stderr, "Failed to modify RC QP to RESET\n");

  2164 -			return 1;

  2165 -		}

  2166 -

  2167 -		if(ctx_modify_qp_to_init(ctx->qp[i],user_param)) {

  2168 -			return 1;

  2169 -		}

  2170 -

  2171 -		if (user_param->use_mcg) {

  2172 -

  2173 -			if ((!user_param->duplex && user_param->machine == SERVER) || (user_param->duplex && i > 0)) {

  2174 -				if (ibv_attach_mcast(ctx->qp[i],&mcg_params->mgid,mcg_params->mlid)) {

  2175 -					fprintf(stderr, "Couldn't attach QP to MultiCast group");

  2176 -					return 1;

  2177 -				}

  2178 -			}

  2179 -		}

  2180 -	}

  2181 -

  2182 -	if (pp_connect_ctx(ctx,psn,dest,user_param)) {

  2183 -		return 1;

  2184 -	}

  2185 -

  2186 -	return 0;

  2187 -}

  2188 -

  2189 -/****************************************************************************** 

  2190 - *

  2191 - ******************************************************************************/

  2192 -static void print_report(struct perftest_parameters *user_param) {

  2193 -

  2194 -	double cycles_to_units;

  2195 -	unsigned long tsize;	/* Transferred size, in megabytes */

  2196 -	int i, j;

  2197 -	int opt_posted = 0, opt_completed = 0;

  2198 -	cycles_t opt_delta;

  2199 -	cycles_t t;

  2200 -

  2201 -

  2202 -	opt_delta = tcompleted[opt_posted] - tposted[opt_completed];

  2203 -

  2204 -	if (user_param->noPeak == OFF) {

  2205 -		/* Find the peak bandwidth, unless asked not to in command line */

  2206 -		for (i = 0; i < user_param->iters; ++i)

  2207 -			for (j = i; j < user_param->iters; ++j) {

  2208 -				t = (tcompleted[j] - tposted[i]) / (j - i + 1);

  2209 -				if (t < opt_delta) {

  2210 -					opt_delta  = t;

  2211 -					opt_posted = i;

  2212 -					opt_completed = j;

  2213 -				}

  2214 -			}

  2215 -	}

  2216 -

  2217 -	cycles_to_units = get_cpu_mhz(user_param->cpu_freq_f) * 1000000;

  2218 -

  2219 -	tsize = user_param->duplex ? 2 : 1;

  2220 -	tsize = tsize * user_param->size;

  2221 -	printf(REPORT_FMT,user_param->size,user_param->iters,(user_param->noPeak == OFF) * tsize * cycles_to_units / opt_delta / 0x100000,

  2222 -	       tsize * user_param->iters * cycles_to_units /(tcompleted[user_param->iters - 1] - tposted[0]) / 0x100000);

  2223 -}

  2224 -

  2225 -/****************************************************************************** 

  2226 - * Important note :															  

  2227 - * In case of UD/UC this is NOT the way to measureBW since we are running with 

  2228 - * loop on the send side , while we should run on the recieve side or enable 

  2229 - * retry in SW , Since the sender may be faster than the reciver.

  2230 - * Although	we had posted recieve it is not enough and might end this will

  2231 - * result in deadlock of test since both sides are stuck on poll cq.

  2232 - * In this test i do not solve this for the general test ,need to write

  2233 - * seperate test for UC/UD but in case the tx_depth is ~1/3 from the

  2234 - * number of iterations this should be ok .

  2235 - * Also note that the sender is limited in the number of send, ans

  2236 - * i try to make the reciver full .

  2237 - ******************************************************************************/

  2238 -int run_iter_bi(struct pingpong_context *ctx, 

  2239 -				struct perftest_parameters *user_param)  {

  2240 -

  2241 -	int                     scnt    = 0;

  2242 -	int 					ccnt    = 0;

  2243 -	int 					rcnt    = 0;

  2244 -	int 					i       = 0;

  2245 -	int 					num_of_qps = user_param->num_of_qps;

  2246 -	int 					ne;

  2247 -	struct ibv_wc 			*wc          = NULL;

  2248 -	int 					*rcnt_for_qp = NULL;

  2249 -	struct ibv_recv_wr      *bad_wr_recv = NULL;

  2250 -	struct ibv_send_wr 		*bad_wr      = NULL;

  2251 -

  2252 -	ALLOCATE(rcnt_for_qp,int,user_param->num_of_qps);

  2253 -	ALLOCATE(wc,struct ibv_wc,DEF_WC_SIZE);

  2254 -	memset(rcnt_for_qp,0,sizeof(int)*user_param->num_of_qps);

  2255 -

  2256 -	if (user_param->use_mcg)

  2257 -		num_of_qps--; 

  2258 -	

  2259 -	// Set the length of the scatter in case of ALL option.

  2260 -	ctx->list.length = user_param->size;

  2261 -	ctx->list.addr   = (uintptr_t)ctx->buf[0];

  2262 -	ctx->wr.send_flags = IBV_SEND_SIGNALED;

  2263 -	

  2264 -	if (user_param->size <= user_param->inline_size) 

  2265 -		ctx->wr.send_flags |= IBV_SEND_INLINE; 

  2266 -

  2267 -	while (ccnt < user_param->iters || rcnt < user_param->iters) {

  2268 -                

  2269 -		while (scnt < user_param->iters && (scnt - ccnt) < user_param->tx_depth / 2) {

  2270 -

  2271 -			if (scnt %  CQ_MODERATION == 0 && CQ_MODERATION > 1)

  2272 -				ctx->wr.send_flags &= ~IBV_SEND_SIGNALED;

  2273 -

  2274 -			tposted[scnt] = get_cycles();

  2275 -			if (ibv_post_send(ctx->qp[0],&ctx->wr, &bad_wr)) {

  2276 -				fprintf(stderr, "Couldn't post send: scnt=%d\n",scnt);

  2277 -				return 1;

  2278 -			}

  2279 -

  2280 -			if (user_param->size <= (CYCLE_BUFFER / 2))

  2281 -				increase_loc_addr(&ctx->list,user_param->size,scnt,(uintptr_t)ctx->buf[0],0);

  2282 -

  2283 -			++scnt;

  2284 -

  2285 -			if ((scnt % CQ_MODERATION) == (CQ_MODERATION - 1) || scnt == (user_param->iters - 1)) 

  2286 -				ctx->wr.send_flags |= IBV_SEND_SIGNALED;

  2287 -		}

  2288 -

  2289 -		if (user_param->use_event) {

  2290 -

  2291 -			if (ctx_notify_events(ctx->cq,ctx->channel)) {

  2292 -				fprintf(stderr,"Failed to notify events to CQ");

  2293 -				return 1;

  2294 -			}

  2295 -		}

  2296 -

  2297 -		do {

  2298 -			ne = ibv_poll_cq(ctx->cq,DEF_WC_SIZE,wc);

  2299 -			if (ne > 0) {

  2300 -				for (i = 0; i < ne; i++) {

  2301 -					

  2302 -					if (wc[i].status != IBV_WC_SUCCESS)

  2303 -						 NOTIFY_COMP_ERROR_SEND(wc[i],scnt,ccnt);

  2304 -

  2305 -					if ((int) wc[i].wr_id == PINGPONG_SEND_WRID) {

  2306 -						ccnt += CQ_MODERATION;

  2307 -						if (ccnt >= user_param->iters - 1) 

  2308 -							tcompleted[user_param->iters - 1] = get_cycles();

  2309 -

  2310 -						else 

  2311 -							tcompleted[ccnt - 1] = get_cycles();

  2312 -					}

  2313 -

  2314 -					else {

  2315 -

  2316 -						rcnt_for_qp[wc[i].wr_id]++;

  2317 -						rcnt++;

  2318 -						if (ibv_post_recv(ctx->qp[wc[i].wr_id],&ctx->rwr[wc[i].wr_id],&bad_wr_recv)) {

  2319 -							fprintf(stderr, "Couldn't post recv Qp=%d rcnt=%d\n",(int)wc[i].wr_id , rcnt_for_qp[wc[i].wr_id]);

  2320 -							return 15;

  2321 -						}

  2322 -

  2323 -						if (user_param->size <= (CYCLE_BUFFER / 2))

  2324 -							increase_loc_addr(&ctx->sge_list[wc[i].wr_id],

  2325 -							  user_param->size,rcnt_for_qp[wc[i].wr_id] + user_param->rx_depth - 1,

  2326 -							  ctx->my_addr[wc[i].wr_id],user_param->connection_type);	

  2327 -					}

  2328 -				}

  2329 -			}

  2330 -		} while (ne > 0);

  2331 -

  2332 -		if (ne < 0) {

  2333 -			fprintf(stderr, "poll CQ failed %d\n", ne);

  2334 -			return 1;

  2335 -		}

  2336 -	}

  2337 -	

  2338 -	if (user_param->size <= user_param->inline_size) 

  2339 -		ctx->wr.send_flags &= ~IBV_SEND_INLINE;

  2340 -	

  2341 -	free(rcnt_for_qp);

  2342 -	free(wc);

  2343 -	return 0;

  2344 -}

  2345 -

  2346 -/****************************************************************************** 

  2347 - *

  2348 - ******************************************************************************/

  2349 -int run_iter_uni_server(struct pingpong_context *ctx, 

  2350 -						struct perftest_parameters *user_param) {

  2351 -

  2352 -	int 				rcnt = 0;

  2353 -	int 				ne,i;

  2354 -	int                 *rcnt_for_qp = NULL;

  2355 -	struct ibv_wc 		*wc          = NULL;

  2356 -	struct ibv_recv_wr  *bad_wr_recv = NULL;

  2357 -

  2358 -	ALLOCATE(wc,struct ibv_wc,DEF_WC_SIZE);

  2359 -	ALLOCATE(rcnt_for_qp,int,user_param->num_of_qps);

  2360 -

  2361 -	memset(rcnt_for_qp,0,sizeof(int)*user_param->num_of_qps);

  2362 -

  2363 -	while (rcnt < user_param->iters) {

  2364 -

  2365 -		if (user_param->use_event) {

  2366 -			if (ctx_notify_events(ctx->cq,ctx->channel)) {

  2367 -				fprintf(stderr ," Failed to notify events to CQ");

  2368 -				return 1;

  2369 -			}

  2370 -		}

  2371 -		

  2372 -		do {

  2373 -			ne = ibv_poll_cq(ctx->cq,DEF_WC_SIZE,wc);

  2374 -			if (ne > 0) {

  2375 -				for (i = 0; i < ne; i++) {

  2376 -					

  2377 -					if (wc[i].status != IBV_WC_SUCCESS) 

  2378 -						NOTIFY_COMP_ERROR_RECV(wc[i],rcnt_for_qp[wc[i].wr_id]);

  2379 -						

  2380 -					rcnt_for_qp[wc[i].wr_id]++;

  2381 -					tcompleted[rcnt++] = get_cycles();

  2382 -

  2383 -				   	if (ibv_post_recv(ctx->qp[wc[i].wr_id],&ctx->rwr[wc[i].wr_id],&bad_wr_recv)) {

  2384 -						fprintf(stderr, "Couldn't post recv Qp=%d rcnt=%d\n",(int)wc[i].wr_id,rcnt_for_qp[wc[i].wr_id]);

  2385 -						return 15;

  2386 -					}

  2387 -

  2388 -					if (user_param->size <= (CYCLE_BUFFER / 2))

  2389 -						increase_loc_addr(&ctx->sge_list[wc[i].wr_id],user_param->size,

  2390 -										  rcnt_for_qp[wc[i].wr_id] + user_param->rx_depth,

  2391 -										  ctx->my_addr[wc[i].wr_id],user_param->connection_type);						

  2392 -				}

  2393 -			}

  2394 -		} while (ne > 0);

  2395 -

  2396 -		if (ne < 0) {

  2397 -			fprintf(stderr, "Poll Recieve CQ failed %d\n", ne);

  2398 -			return 1;

  2399 -		}

  2400 -	}

  2401 -

  2402 -	tposted[0] = tcompleted[0];

  2403 -	free(wc);

  2404 -	free(rcnt_for_qp);

  2405 -	return 0;

  2406 -}

  2407 -

  2408 -/****************************************************************************** 

  2409 - *

  2410 - ******************************************************************************/

  2411 -int run_iter_uni_client(struct pingpong_context *ctx, 

  2412 -						struct perftest_parameters *user_param) {

  2413 -

  2414 -	int 		       ne;

  2415 -	int 			   i    = 0;

  2416 -	int                scnt = 0;

  2417 -	int                ccnt = 0;

  2418 -	struct ibv_wc      *wc     = NULL;

  2419 -	struct ibv_send_wr *bad_wr = NULL;

  2420 -

  2421 -	ALLOCATE(wc,struct ibv_wc,DEF_WC_SIZE);

  2422 -

  2423 -	// Set the lenght of the scatter in case of ALL option.

  2424 -	ctx->list.length = user_param->size;

  2425 -	ctx->list.addr   = (uintptr_t)ctx->buf[0];

  2426 -	ctx->wr.send_flags = IBV_SEND_SIGNALED; 

  2427 -

  2428 -	if (user_param->size <= user_param->inline_size) 

  2429 -		ctx->wr.send_flags |= IBV_SEND_INLINE; 

  2430 -	

  2431 -

  2432 -	while (scnt < user_param->iters || ccnt < user_param->iters) {

  2433 -		while (scnt < user_param->iters && (scnt - ccnt) < user_param->tx_depth ) {

  2434 -

  2435 -			if (scnt %  CQ_MODERATION == 0 && CQ_MODERATION > 1)

  2436 -				ctx->wr.send_flags &= ~IBV_SEND_SIGNALED;

  2437 -

  2438 -			tposted[scnt] = get_cycles();

  2439 -			if (ibv_post_send(ctx->qp[0], &ctx->wr, &bad_wr)) {

  2440 -				fprintf(stderr, "Couldn't post send: scnt=%d\n",scnt);

  2441 -				return 1;

  2442 -			}

  2443 -

  2444 -			if (user_param->size <= (CYCLE_BUFFER / 2))

  2445 -				increase_loc_addr(&ctx->list,user_param->size,scnt,(uintptr_t)ctx->buf[0],0);

  2446 -

  2447 -			scnt++;

  2448 -

  2449 -			if ((scnt % CQ_MODERATION) == (CQ_MODERATION - 1) || scnt == (user_param->iters - 1)) 

  2450 -				ctx->wr.send_flags |= IBV_SEND_SIGNALED;

  2451 -		}

  2452 -

  2453 -		if (ccnt < user_param->iters) {	

  2454 -			

  2455 -			if (user_param->use_event) {

  2456 -				if (ctx_notify_events(ctx->cq,ctx->channel)) {

  2457 -					fprintf(stderr , " Failed to notify events to CQ");

  2458 -					return 1;

  2459 -				}

  2460 -			} 

  2461 -			do {

  2462 -				ne = ibv_poll_cq(ctx->cq,DEF_WC_SIZE,wc);

  2463 -				if (ne > 0) {

  2464 -					for (i = 0; i < DEF_WC_SIZE; i++) {

  2465 -

  2466 -						if (wc[i].status != IBV_WC_SUCCESS) 

  2467 -							NOTIFY_COMP_ERROR_SEND(wc[i],scnt,ccnt);

  2468 -			

  2469 -						ccnt += CQ_MODERATION;

  2470 -						if (ccnt >= user_param->iters - 1) 

  2471 -							tcompleted[user_param->iters - 1] = get_cycles();

  2472 -

  2473 -						else 

  2474 -							tcompleted[ccnt - 1] = get_cycles();

  2475 -					}

  2476 -				}

  2477 -                         

  2478 -					

  2479 -			} while (ne > 0);

  2480 -

  2481 -			if (ne < 0) {

  2482 -				fprintf(stderr, "poll CQ failed\n");

  2483 -				return 1;

  2484 -			}

  2485 -		}

  2486 -	}

  2487 -

  2488 -	if (user_param->size <= user_param->inline_size) 

  2489 -		ctx->wr.send_flags &= ~IBV_SEND_INLINE;

  2490 -

  2491 -	free(wc);

  2492 -	return 0;

  2493 -}

  2494 -

  2495 -/****************************************************************************** 

  2496 - *

  2497 - ******************************************************************************/

  2498 -int main(int argc, char *argv[])

  2499 -{

  2500 -	struct ibv_device		 	*ib_dev = NULL;

  2501 -	struct pingpong_context  	*ctx;

  2502 -	struct pingpong_dest	 	my_dest,rem_dest;

  2503 -	struct perftest_parameters  user_param;

  2504 -	struct mcast_parameters     mcg_params;

  2505 -	int                      	i = 0;

  2506 -	int                      	size_max_pow = 24;

  2507 -	int							size_of_arr;

  2508 -

  2509 -	// Pointer to The relevent function of run_iter according to machine type.

  2510 -	int (*ptr_to_run_iter_uni)(struct pingpong_context*,struct perftest_parameters*);

  2511 -

  2512 -	/* init default values to user's parameters */

  2513 -	memset(&user_param, 0 , sizeof(struct perftest_parameters));

  2514 -	memset(&mcg_params, 0 , sizeof(struct mcast_parameters));

  2515 -	memset(&my_dest   , 0 , sizeof(struct pingpong_dest));

  2516 -	memset(&rem_dest   , 0 , sizeof(struct pingpong_dest));

  2517 - 

  2518 -	user_param.verb    = SEND;

  2519 -	user_param.tst     = BW;

  2520 -	user_param.version = VERSION;

  2521 -

  2522 -	if (parser(&user_param,argv,argc)) 

  2523 -		return 1;

  2524 -

  2525 -	printf(RESULT_LINE);

  2526 -

  2527 -	user_param.rx_depth = (user_param.iters < user_param.rx_depth) ? user_param.iters : user_param.rx_depth ;

  2528 -

  2529 -    if (user_param.use_mcg) {

  2530 -

  2531 -		user_param.connection_type = UD;

  2532 -		if (user_param.duplex) {

  2533 -			user_param.num_of_qps++;

  2534 -			printf("                    Send Bidirectional BW  -  Multicast Test\n");

  2535 -		}

  2536 -		else {

  2537 -			printf("                    Send BW  -  Multicast Test\n");

  2538 -			if (user_param.machine == CLIENT)

  2539 -				user_param.num_of_qps = 1;

  2540 -		}

  2541 -    }

  2542 -

  2543 -	else if (user_param.duplex) {

  2544 -		    printf("                    Send Bidirectional BW Test\n");

  2545 -	} else 

  2546 -		    printf("                    Send BW Test\n");

  2547 -

  2548 -	if (user_param.use_event) 

  2549 -		printf(" Test with events.\n");

  2550 -

  2551 -	if (user_param.connection_type == RC)

  2552 -		printf(" Connection type : RC\n");

  2553 -	else if (user_param.connection_type == UC)

  2554 -		printf(" Connection type : UC\n");

  2555 -	else{

  2556 -		printf(" Connection type : UD\n");

  2557 -	}

  2558 -	

  2559 -	// Done with parameter parsing. Perform setup.

  2560 -	if (user_param.all == ON) {

  2561 -		// since we run all sizes 

  2562 -		user_param.size = MAX_SIZE;

  2563 -	}

  2564 -

  2565 -	srand48(getpid() * time(NULL));

  2566 -	page_size = sysconf(_SC_PAGESIZE);

  2567 -

  2568 -	ib_dev = ctx_find_dev(user_param.ib_devname);

  2569 -	if (!ib_dev)

  2570 -		return 7;

  2571 -

  2572 -	mcg_params.ib_devname = ibv_get_device_name(ib_dev);

  2573 -

  2574 -	ctx = pp_init_ctx(ib_dev,&user_param);

  2575 -	if (!ctx)

  2576 -		return 1;

  2577 -

  2578 -	// Set up the Connection.

  2579 -	if (set_up_connection(ctx,&user_param,&my_dest,&mcg_params)) {

  2580 -		fprintf(stderr," Unable to set up socket connection\n");

  2581 -		return 1;

  2582 -	}	

  2583 -

  2584 -	// Init the connection and print the local data.

  2585 -	if (init_connection(&user_param,&my_dest)) {

  2586 -		fprintf(stderr," Unable to init the socket connection\n");

  2587 -		return 1;

  2588 -	}

  2589 -

  2590 -	// shaking hands and gather the other side info.

  2591 -    if (ctx_hand_shake(&user_param,&my_dest,&rem_dest)) {

  2592 -        fprintf(stderr,"Failed to exchange date between server and clients\n");

  2593 -        return 1;

  2594 -        

  2595 -    }

  2596 -	// For printing only MGID in the remote side.

  2597 -	user_param.side = REMOTE;

  2598 -	ctx_print_pingpong_data(&rem_dest,&user_param);

  2599 -

  2600 -	// Joining the Send side port the Mcast gid

  2601 -	if (user_param.use_mcg && (user_param.machine == CLIENT || user_param.duplex)) {

  2602 -		memcpy(mcg_params.mgid.raw, rem_dest.gid.raw, 16);

  2603 -		if (set_mcast_group(ctx,&user_param,&mcg_params)) {

  2604 -			fprintf(stderr," Unable to Join Sender to Mcast gid\n");

  2605 -			return 1;

  2606 -		}

  2607 -	}

  2608 -

  2609 -	// Prepare IB resources for rtr/rts.

  2610 -	if (pp_connect_ctx(ctx,my_dest.psn,&rem_dest,&user_param)) {

  2611 -		fprintf(stderr," Unable to Connect the HCA's through the link\n");

  2612 -		return 1;

  2613 -	}

  2614 -	

  2615 -	// shaking hands and gather the other side info.

  2616 -    if (ctx_hand_shake(&user_param,&my_dest,&rem_dest)) {

  2617 -        fprintf(stderr,"Failed to exchange date between server and clients\n");

  2618 -        return 1;

  2619 -        

  2620 -    }

  2621 -

  2622 -	if (user_param.use_event) {

  2623 -		if (ibv_req_notify_cq(ctx->cq, 0)) {

  2624 -			fprintf(stderr, " Couldn't request CQ notification\n");

  2625 -			return 1;

  2626 -		} 

  2627 -	}

  2628 -

  2629 -	printf(RESULT_LINE);

  2630 -	printf(RESULT_FMT);

  2631 -

  2632 -	size_of_arr = (user_param.duplex) ? 1 : user_param.num_of_qps;

  2633 -

  2634 -	ALLOCATE(tposted,cycles_t,user_param.iters*size_of_arr);

  2635 -	ALLOCATE(tcompleted,cycles_t,user_param.iters*size_of_arr);

  2636 -

  2637 -	if (user_param.machine == SERVER || user_param.duplex) {

  2638 -		ALLOCATE(ctx->rwr,struct ibv_recv_wr,user_param.num_of_qps);

  2639 -		ALLOCATE(ctx->sge_list,struct ibv_sge,user_param.num_of_qps);

  2640 -		ALLOCATE(ctx->my_addr ,uint64_t ,user_param.num_of_qps);

  2641 -	}

  2642 -

  2643 -	ptr_to_run_iter_uni = (user_param.machine == CLIENT) ?	&run_iter_uni_client : &run_iter_uni_server;

  2644 -	

  2645 -	if (user_param.machine == SERVER && !user_param.duplex) {

  2646 -		user_param.noPeak = ON;

  2647 -	}

  2648 -

  2649 -	if (user_param.machine == CLIENT || user_param.duplex) {

  2650 -		set_send_wqe(ctx,rem_dest.qpn,&user_param);

  2651 -	}

  2652 -

  2653 -	if (user_param.all == ON) {

  2654 -

  2655 -		if (user_param.connection_type == UD) 

  2656 -		   size_max_pow =  (int)UD_MSG_2_EXP(MTU_SIZE(user_param.curr_mtu)) + 1;

  2657 -

  2658 -		for (i = 1; i < size_max_pow ; ++i) {

  2659 -			user_param.size = 1 << i;

  2660 -

  2661 -			if (user_param.machine == SERVER || user_param.duplex) {

  2662 -				if (set_recv_wqes(ctx,&user_param)) {

  2663 -					fprintf(stderr," Failed to post receive recv_wqes\n");

  2664 -					return 1;

  2665 -				}

  2666 -			}

  2667 -

  2668 -			if (ctx_hand_shake(&user_param,&my_dest,&rem_dest)) {

  2669 -				fprintf(stderr,"Failed to exchange date between server and clients\n");

  2670 -				return 1;

  2671 -			}

  2672 -

  2673 -			if (user_param.duplex) {

  2674 -				if(run_iter_bi(ctx,&user_param))

  2675 -					return 17;

  2676 -			} else {

  2677 -				if((*ptr_to_run_iter_uni)(ctx,&user_param))

  2678 -					return 17;

  2679 -			}

  2680 -			print_report(&user_param);

  2681 -

  2682 -			if (pp_drain_qp(ctx,&user_param,my_dest.psn,&rem_dest,&mcg_params)) {

  2683 -				fprintf(stderr,"Failed to drain Recv queue (performance optimization)\n");

  2684 -				return 1;

  2685 -			}

  2686 -

  2687 -			if (ctx_hand_shake(&user_param,&my_dest,&rem_dest)) {

  2688 -				fprintf(stderr,"Failed to exchange date between server and clients\n");

  2689 -				return 1;

  2690 -			}

  2691 -        

  2692 -		}

  2693 -

  2694 -	} else {