From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from dpdk.org (dpdk.org [92.243.14.124]) by inbox.dpdk.org (Postfix) with ESMTP id 0423CA04B5; Mon, 7 Sep 2020 13:26:45 +0200 (CEST) Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id CAA371C1A9; Mon, 7 Sep 2020 13:24:53 +0200 (CEST) Received: from mga14.intel.com (mga14.intel.com [192.55.52.115]) by dpdk.org (Postfix) with ESMTP id CF1291C19B for ; Mon, 7 Sep 2020 13:24:50 +0200 (CEST) IronPort-SDR: YybCKZ5aBSuCZmhn+UvihqUHxYo69aFxXVPUtYsOAx4IfxYrEHCFnEqCnd4J0GnHfdTWeL5X7z N6RuZhu8ueJw== X-IronPort-AV: E=McAfee;i="6000,8403,9736"; a="157252611" X-IronPort-AV: E=Sophos;i="5.76,401,1592895600"; d="scan'208";a="157252611" X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False Received: from fmsmga004.fm.intel.com ([10.253.24.48]) by fmsmga103.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 07 Sep 2020 04:24:50 -0700 IronPort-SDR: i2XbvlQOVzUW/B94LCiOhyvVGA2nJTPbmRckddTgpF+/JIYy9MUoW+HX+xfwaZn7YgwZreoRuY JPLvbGFg0nmQ== X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.76,401,1592895600"; d="scan'208";a="328058791" Received: from dpdk51.sh.intel.com ([10.67.111.82]) by fmsmga004.fm.intel.com with ESMTP; 07 Sep 2020 04:24:49 -0700 From: Qi Zhang To: qiming.yang@intel.com Cc: dev@dpdk.org, Qi Zhang , Bruce Allan Date: Mon, 7 Sep 2020 19:27:59 +0800 Message-Id: <20200907112826.48493-14-qi.z.zhang@intel.com> X-Mailer: git-send-email 2.13.6 In-Reply-To: <20200907112826.48493-1-qi.z.zhang@intel.com> References: <20200907112826.48493-1-qi.z.zhang@intel.com> Subject: [dpdk-dev] [PATCH 13/40] net/ice/base: introduce and use for each bit iterator X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Sender: "dev" A number of code flows iterate over a block of memory to do something for every bit set in that memory. Use existing bit operations in a new iterator macro to make those code flows cleaner. Signed-off-by: Bruce Allan Signed-off-by: Qi Zhang --- drivers/net/ice/base/ice_acl_ctrl.c | 17 +++----- drivers/net/ice/base/ice_bitops.h | 5 +++ drivers/net/ice/base/ice_flex_pipe.c | 66 ++++++++++++++----------------- drivers/net/ice/base/ice_flow.c | 75 +++++++++++------------------------- drivers/net/ice/base/ice_switch.c | 59 ++++++++++++---------------- 5 files changed, 85 insertions(+), 137 deletions(-) diff --git a/drivers/net/ice/base/ice_acl_ctrl.c b/drivers/net/ice/base/ice_acl_ctrl.c index a732397ce..49c4f3675 100644 --- a/drivers/net/ice/base/ice_acl_ctrl.c +++ b/drivers/net/ice/base/ice_acl_ctrl.c @@ -1028,9 +1028,8 @@ ice_acl_prog_act(struct ice_hw *hw, struct ice_acl_scen *scen, entry_tcam = ICE_ACL_TBL_TCAM_IDX(scen->start); idx = ICE_ACL_TBL_TCAM_ENTRY_IDX(scen->start + entry_idx); - i = ice_find_first_bit(scen->act_mem_bitmap, - ICE_AQC_MAX_ACTION_MEMORIES); - while (i < ICE_AQC_MAX_ACTION_MEMORIES) { + ice_for_each_set_bit(i, scen->act_mem_bitmap, + ICE_AQC_MAX_ACTION_MEMORIES) { struct ice_acl_act_mem *mem = &hw->acl_tbl->act_mems[i]; if (actx_idx >= acts_cnt) @@ -1057,9 +1056,6 @@ ice_acl_prog_act(struct ice_hw *hw, struct ice_acl_scen *scen, } actx_idx++; } - - i = ice_find_next_bit(scen->act_mem_bitmap, - ICE_AQC_MAX_ACTION_MEMORIES, i + 1); } if (!status && actx_idx < acts_cnt) @@ -1111,9 +1107,9 @@ ice_acl_rem_entry(struct ice_hw *hw, struct ice_acl_scen *scen, u16 entry_idx) } ice_memset(&act_buf, 0, sizeof(act_buf), ICE_NONDMA_MEM); - i = ice_find_first_bit(scen->act_mem_bitmap, - ICE_AQC_MAX_ACTION_MEMORIES); - while (i < ICE_AQC_MAX_ACTION_MEMORIES) { + + ice_for_each_set_bit(i, scen->act_mem_bitmap, + ICE_AQC_MAX_ACTION_MEMORIES) { struct ice_acl_act_mem *mem = &hw->acl_tbl->act_mems[i]; if (mem->member_of_tcam >= entry_tcam && @@ -1126,9 +1122,6 @@ ice_acl_rem_entry(struct ice_hw *hw, struct ice_acl_scen *scen, u16 entry_idx) "program actpair failed.status: %d\n", status); } - - i = ice_find_next_bit(scen->act_mem_bitmap, - ICE_AQC_MAX_ACTION_MEMORIES, i + 1); } ice_acl_scen_free_entry_idx(scen, entry_idx); diff --git a/drivers/net/ice/base/ice_bitops.h b/drivers/net/ice/base/ice_bitops.h index a56d55455..f954a7436 100644 --- a/drivers/net/ice/base/ice_bitops.h +++ b/drivers/net/ice/base/ice_bitops.h @@ -346,6 +346,11 @@ static inline u16 ice_find_first_bit(const ice_bitmap_t *bitmap, u16 size) return ice_find_next_bit(bitmap, size, 0); } +#define ice_for_each_set_bit(_bitpos, _addr, _maxlen) \ + for ((_bitpos) = ice_find_first_bit((_addr), (_maxlen)); \ + (_bitpos) < (_maxlen); \ + (_bitpos) = ice_find_next_bit((_addr), (_maxlen), (_bitpos) + 1)) + /** * ice_is_any_bit_set - Return true of any bit in the bitmap is set * @bitmap: the bitmap to check diff --git a/drivers/net/ice/base/ice_flex_pipe.c b/drivers/net/ice/base/ice_flex_pipe.c index a08390992..3df7b8596 100644 --- a/drivers/net/ice/base/ice_flex_pipe.c +++ b/drivers/net/ice/base/ice_flex_pipe.c @@ -4665,50 +4665,42 @@ ice_add_prof(struct ice_hw *hw, enum ice_block blk, u64 id, u8 ptypes[], byte++; continue; } + /* Examine 8 bits per byte */ - for (bit = 0; bit < 8; bit++) { - if (ptypes[byte] & BIT(bit)) { - u16 ptype; - u8 ptg; - u8 m; + ice_for_each_set_bit(bit, (ice_bitmap_t *)&ptypes[byte], + BITS_PER_BYTE) { + u16 ptype; + u8 ptg; - ptype = byte * BITS_PER_BYTE + bit; + ptype = byte * BITS_PER_BYTE + bit; - /* The package should place all ptypes in a - * non-zero PTG, so the following call should - * never fail. - */ - if (ice_ptg_find_ptype(hw, blk, ptype, &ptg)) - continue; + /* The package should place all ptypes in a non-zero + * PTG, so the following call should never fail. + */ + if (ice_ptg_find_ptype(hw, blk, ptype, &ptg)) + continue; - /* If PTG is already added, skip and continue */ - if (ice_is_bit_set(ptgs_used, ptg)) - continue; + /* If PTG is already added, skip and continue */ + if (ice_is_bit_set(ptgs_used, ptg)) + continue; - ice_set_bit(ptg, ptgs_used); - /* Check to see there are any attributes for - * this ptype, and add them if found. + ice_set_bit(ptg, ptgs_used); + /* Check to see there are any attributes for this + * ptype, and add them if found. + */ + status = ice_add_prof_attrib(prof, ptg, ptype, attr, + attr_cnt); + if (status == ICE_ERR_MAX_LIMIT) + break; + if (status) { + /* This is simple a ptype/PTG with no + * attribute */ - status = ice_add_prof_attrib(prof, ptg, ptype, - attr, attr_cnt); - if (status == ICE_ERR_MAX_LIMIT) - break; - if (status) { - /* This is simple a ptype/PTG with no - * attribute - */ - prof->ptg[prof->ptg_cnt] = ptg; - prof->attr[prof->ptg_cnt].flags = 0; - prof->attr[prof->ptg_cnt].mask = 0; - - if (++prof->ptg_cnt >= - ICE_MAX_PTG_PER_PROFILE) - break; - } + prof->ptg[prof->ptg_cnt] = ptg; + prof->attr[prof->ptg_cnt].flags = 0; + prof->attr[prof->ptg_cnt].mask = 0; - /* nothing left in byte, then exit */ - m = ~(u8)((1 << (bit + 1)) - 1); - if (!(ptypes[byte] & m)) + if (++prof->ptg_cnt >= ICE_MAX_PTG_PER_PROFILE) break; } } diff --git a/drivers/net/ice/base/ice_flow.c b/drivers/net/ice/base/ice_flow.c index d68a9ca5d..cd56f46f4 100644 --- a/drivers/net/ice/base/ice_flow.c +++ b/drivers/net/ice/base/ice_flow.c @@ -1340,16 +1340,12 @@ ice_flow_create_xtrct_seq(struct ice_hw *hw, u64 match = params->prof->segs[i].match; enum ice_flow_field j; - for (j = 0; j < ICE_FLOW_FIELD_IDX_MAX && match; j++) { - const u64 bit = BIT_ULL(j); - - if (match & bit) { - status = ice_flow_xtract_fld(hw, params, i, j, - match); - if (status) - return status; - match &= ~bit; - } + ice_for_each_set_bit(j, (ice_bitmap_t *)&match, + ICE_FLOW_FIELD_IDX_MAX) { + status = ice_flow_xtract_fld(hw, params, i, j, match); + if (status) + return status; + ice_clear_bit(j, (ice_bitmap_t *)&match); } /* Process raw matching bytes */ @@ -1406,17 +1402,12 @@ ice_flow_acl_def_entry_frmt(struct ice_flow_prof_params *params) for (i = 0; i < params->prof->segs_cnt; i++) { struct ice_flow_seg_info *seg = ¶ms->prof->segs[i]; - u64 match = seg->match; u8 j; - for (j = 0; j < ICE_FLOW_FIELD_IDX_MAX && match; j++) { - struct ice_flow_fld_info *fld; - const u64 bit = BIT_ULL(j); + ice_for_each_set_bit(j, (ice_bitmap_t *)&seg->match, + ICE_FLOW_FIELD_IDX_MAX) { + struct ice_flow_fld_info *fld = &seg->fields[j]; - if (!(match & bit)) - continue; - - fld = &seg->fields[j]; fld->entry.mask = ICE_FLOW_FLD_OFF_INVAL; if (fld->type == ICE_FLOW_FLD_TYPE_RANGE) { @@ -1448,8 +1439,6 @@ ice_flow_acl_def_entry_frmt(struct ice_flow_prof_params *params) fld->entry.val = index; index += fld->entry.last; } - - match &= ~bit; } for (j = 0; j < seg->raws_cnt; j++) { @@ -2028,25 +2017,18 @@ ice_flow_acl_set_xtrct_seq(struct ice_hw *hw, struct ice_flow_prof *prof) for (i = 0; i < prof->segs_cnt; i++) { struct ice_flow_seg_info *seg = &prof->segs[i]; - u64 match = seg->match; u16 j; - for (j = 0; j < ICE_FLOW_FIELD_IDX_MAX && match; j++) { - const u64 bit = BIT_ULL(j); - - if (!(match & bit)) - continue; - + ice_for_each_set_bit(j, (ice_bitmap_t *)&seg->match, + ICE_FLOW_FIELD_IDX_MAX) { info = &seg->fields[j]; if (info->type == ICE_FLOW_FLD_TYPE_RANGE) buf.word_selection[info->entry.val] = - info->xtrct.idx; + info->xtrct.idx; else ice_flow_acl_set_xtrct_seq_fld(&buf, info); - - match &= ~bit; } for (j = 0; j < seg->raws_cnt; j++) { @@ -2549,17 +2531,11 @@ ice_flow_acl_frmt_entry(struct ice_hw *hw, struct ice_flow_prof *prof, for (i = 0; i < prof->segs_cnt; i++) { struct ice_flow_seg_info *seg = &prof->segs[i]; - u64 match = seg->match; - u16 j; - - for (j = 0; j < ICE_FLOW_FIELD_IDX_MAX && match; j++) { - struct ice_flow_fld_info *info; - const u64 bit = BIT_ULL(j); - - if (!(match & bit)) - continue; + u8 j; - info = &seg->fields[j]; + ice_for_each_set_bit(j, (ice_bitmap_t *)&seg->match, + ICE_FLOW_FIELD_IDX_MAX) { + struct ice_flow_fld_info *info = &seg->fields[j]; if (info->type == ICE_FLOW_FLD_TYPE_RANGE) ice_flow_acl_frmt_entry_range(j, info, @@ -2568,8 +2544,6 @@ ice_flow_acl_frmt_entry(struct ice_hw *hw, struct ice_flow_prof *prof, else ice_flow_acl_frmt_entry_fld(j, info, buf, dontcare, data); - - match &= ~bit; } for (j = 0; j < seg->raws_cnt; j++) { @@ -3271,20 +3245,15 @@ static enum ice_status ice_flow_set_rss_seg_info(struct ice_flow_seg_info *segs, u64 hash_fields, u32 flow_hdr) { - u64 val = hash_fields; + u64 val; u8 i; - for (i = 0; val && i < ICE_FLOW_FIELD_IDX_MAX; i++) { - u64 bit = BIT_ULL(i); + ice_for_each_set_bit(i, (ice_bitmap_t *)&hash_fields, + ICE_FLOW_FIELD_IDX_MAX) + ice_flow_set_fld(segs, (enum ice_flow_field)i, + ICE_FLOW_FLD_OFF_INVAL, ICE_FLOW_FLD_OFF_INVAL, + ICE_FLOW_FLD_OFF_INVAL, false); - if (val & bit) { - ice_flow_set_fld(segs, (enum ice_flow_field)i, - ICE_FLOW_FLD_OFF_INVAL, - ICE_FLOW_FLD_OFF_INVAL, - ICE_FLOW_FLD_OFF_INVAL, false); - val &= ~bit; - } - } ICE_FLOW_SET_HDRS(segs, flow_hdr); if (segs->hdrs & ~ICE_FLOW_RSS_SEG_HDR_VAL_MASKS & diff --git a/drivers/net/ice/base/ice_switch.c b/drivers/net/ice/base/ice_switch.c index ecb411714..f2d8514be 100644 --- a/drivers/net/ice/base/ice_switch.c +++ b/drivers/net/ice/base/ice_switch.c @@ -1374,9 +1374,8 @@ static void ice_get_recp_to_prof_map(struct ice_hw *hw) continue; ice_cp_bitmap(profile_to_recipe[i], r_bitmap, ICE_MAX_NUM_RECIPES); - for (j = 0; j < ICE_MAX_NUM_RECIPES; j++) - if (ice_is_bit_set(r_bitmap, j)) - ice_set_bit(i, recipe_to_profile[j]); + ice_for_each_set_bit(j, r_bitmap, ICE_MAX_NUM_RECIPES) + ice_set_bit(i, recipe_to_profile[j]); } } @@ -5946,26 +5945,21 @@ ice_find_free_recp_res_idx(struct ice_hw *hw, const ice_bitmap_t *profiles, * the set of recipes that our recipe may collide with. Also, determine * what possible result indexes are usable given this set of profiles. */ - bit = 0; - while (ICE_MAX_NUM_PROFILES > - (bit = ice_find_next_bit(profiles, ICE_MAX_NUM_PROFILES, bit))) { + ice_for_each_set_bit(bit, profiles, ICE_MAX_NUM_PROFILES) { ice_or_bitmap(recipes, recipes, profile_to_recipe[bit], ICE_MAX_NUM_RECIPES); ice_and_bitmap(possible_idx, possible_idx, hw->switch_info->prof_res_bm[bit], ICE_MAX_FV_WORDS); - bit++; } /* For each recipe that our new recipe may collide with, determine * which indexes have been used. */ - for (bit = 0; bit < ICE_MAX_NUM_RECIPES; bit++) - if (ice_is_bit_set(recipes, bit)) { - ice_or_bitmap(used_idx, used_idx, - hw->switch_info->recp_list[bit].res_idxs, - ICE_MAX_FV_WORDS); - } + ice_for_each_set_bit(bit, recipes, ICE_MAX_NUM_RECIPES) + ice_or_bitmap(used_idx, used_idx, + hw->switch_info->recp_list[bit].res_idxs, + ICE_MAX_FV_WORDS); ice_xor_bitmap(free_idx, used_idx, possible_idx, ICE_MAX_FV_WORDS); @@ -6650,18 +6644,17 @@ ice_add_adv_recipe(struct ice_hw *hw, struct ice_adv_lkup_elem *lkups, if (LIST_EMPTY(&rm->fv_list)) { u16 j; - for (j = 0; j < ICE_MAX_NUM_PROFILES; j++) - if (ice_is_bit_set(fv_bitmap, j)) { - struct ice_sw_fv_list_entry *fvl; - - fvl = (struct ice_sw_fv_list_entry *) - ice_malloc(hw, sizeof(*fvl)); - if (!fvl) - goto err_unroll; - fvl->fv_ptr = NULL; - fvl->profile_id = j; - LIST_ADD(&fvl->list_entry, &rm->fv_list); - } + ice_for_each_set_bit(j, fv_bitmap, ICE_MAX_NUM_PROFILES) { + struct ice_sw_fv_list_entry *fvl; + + fvl = (struct ice_sw_fv_list_entry *) + ice_malloc(hw, sizeof(*fvl)); + if (!fvl) + goto err_unroll; + fvl->fv_ptr = NULL; + fvl->profile_id = j; + LIST_ADD(&fvl->list_entry, &rm->fv_list); + } } /* get bitmap of all profiles the recipe will be associated with */ @@ -6716,10 +6709,9 @@ ice_add_adv_recipe(struct ice_hw *hw, struct ice_adv_lkup_elem *lkups, ICE_MAX_NUM_RECIPES); /* Update recipe to profile bitmap array */ - for (j = 0; j < ICE_MAX_NUM_RECIPES; j++) - if (ice_is_bit_set(r_bitmap, j)) - ice_set_bit((u16)fvit->profile_id, - recipe_to_profile[j]); + ice_for_each_set_bit(j, rm->r_bitmap, ICE_MAX_NUM_RECIPES) + ice_set_bit((u16)fvit->profile_id, + recipe_to_profile[j]); } *rid = rm->root_rid; @@ -7909,6 +7901,7 @@ ice_replay_fltr(struct ice_hw *hw, u8 recp_id, struct LIST_HEAD_TYPE *list_head) LIST_FOR_EACH_ENTRY(itr, &l_head, ice_fltr_mgmt_list_entry, list_entry) { struct ice_fltr_list_entry f_entry; + u16 vsi_handle; f_entry.fltr_info = itr->fltr_info; if (itr->vsi_count < 2 && recp_id != ICE_SW_LKUP_VLAN) { @@ -7920,12 +7913,8 @@ ice_replay_fltr(struct ice_hw *hw, u8 recp_id, struct LIST_HEAD_TYPE *list_head) } /* Add a filter per VSI separately */ - while (1) { - u16 vsi_handle; - - vsi_handle = - ice_find_first_bit(itr->vsi_list_info->vsi_map, - ICE_MAX_VSI); + ice_for_each_set_bit(vsi_handle, itr->vsi_list_info->vsi_map, + ICE_MAX_VSI) { if (!ice_is_vsi_valid(hw, vsi_handle)) break; -- 2.13.6