int MsgItem::ByteSize() const {
int total_size = 0;
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
// optional int32 sku = 1;
if (has_sku()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->sku());
}
// optional int32 position = 2;
if (has_position()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->position());
}
// optional int32 sequence = 4;
if (has_sequence()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->sequence());
}
// optional int32 counter = 5;
if (has_counter()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->counter());
}
// optional int32 quantity = 6;
if (has_quantity()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->quantity());
}
// optional int32 timeLeft = 7;
if (has_timeleft()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->timeleft());
}
}
// repeated int32 Item = 3;
{
int data_size = 0;
for (int i = 0; i < this->item_size(); i++) {
data_size += ::google::protobuf::internal::WireFormatLite::
Int32Size(this->item(i));
}
total_size += 1 * this->item_size() + data_size;
}
if (!unknown_fields().empty()) {
total_size +=
::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
unknown_fields());
}
_cached_size_ = total_size;
return total_size;
}
/*
* Automatically dispatch events to corresponding counters following constraints.
* Upon return the pfarg_reg_t structure is ready to be submitted to kernel
*/
static int
pfm_gen_ia64_dispatch_counters(pfmlib_input_param_t *inp, pfmlib_output_param_t *outp)
{
#define has_counter(e,b) (pfm_regmask_isset(&generic_pe[e].pme_counters, b) ? b : 0)
unsigned int max_l0, max_l1, max_l2, max_l3;
unsigned int assign[PMU_GEN_IA64_MAX_COUNTERS];
pfm_gen_ia64_pmc_reg_t reg;
pfmlib_event_t *e;
pfmlib_reg_t *pc, *pd;
pfmlib_regmask_t *r_pmcs;
unsigned int i,j,k,l;
unsigned int cnt;
e = inp->pfp_events;
pc = outp->pfp_pmcs;
pd = outp->pfp_pmds;
cnt = inp->pfp_event_count;
r_pmcs = &inp->pfp_unavail_pmcs;
if (cnt > PMU_GEN_IA64_MAX_COUNTERS) return PFMLIB_ERR_TOOMANY;
max_l0 = PMU_GEN_IA64_FIRST_COUNTER + PMU_GEN_IA64_MAX_COUNTERS;
max_l1 = PMU_GEN_IA64_FIRST_COUNTER + PMU_GEN_IA64_MAX_COUNTERS*(cnt>1);
max_l2 = PMU_GEN_IA64_FIRST_COUNTER + PMU_GEN_IA64_MAX_COUNTERS*(cnt>2);
max_l3 = PMU_GEN_IA64_FIRST_COUNTER + PMU_GEN_IA64_MAX_COUNTERS*(cnt>3);
if (PFMLIB_DEBUG()) {
DPRINT("max_l0=%u max_l1=%u max_l2=%u max_l3=%u\n", max_l0, max_l1, max_l2, max_l3);
}
/*
* This code needs fixing. It is not very pretty and
* won't handle more than 4 counters if more become
* available !
* For now, worst case in the loop nest: 4! (factorial)
*/
for (i=PMU_GEN_IA64_FIRST_COUNTER; i < max_l0; i++) {
assign[0]= has_counter(e[0].event,i);
if (max_l1 == PMU_GEN_IA64_FIRST_COUNTER && valid_assign(assign, r_pmcs, cnt)) goto done;
for (j=PMU_GEN_IA64_FIRST_COUNTER; j < max_l1; j++) {
if (j == i) continue;
assign[1] = has_counter(e[1].event,j);
if (max_l2 == PMU_GEN_IA64_FIRST_COUNTER && valid_assign(assign, r_pmcs, cnt)) goto done;
for (k=PMU_GEN_IA64_FIRST_COUNTER; k < max_l2; k++) {
if(k == i || k == j) continue;
assign[2] = has_counter(e[2].event,k);
if (max_l3 == PMU_GEN_IA64_FIRST_COUNTER && valid_assign(assign, r_pmcs, cnt)) goto done;
for (l=PMU_GEN_IA64_FIRST_COUNTER; l < max_l3; l++) {
if(l == i || l == j || l == k) continue;
assign[3] = has_counter(e[3].event,l);
if (valid_assign(assign, r_pmcs, cnt)) goto done;
}
}
}
}
/* we cannot satisfy the constraints */
return PFMLIB_ERR_NOASSIGN;
done:
memset(pc, 0, cnt*sizeof(pfmlib_reg_t));
memset(pd, 0, cnt*sizeof(pfmlib_reg_t));
for (j=0; j < cnt ; j++ ) {
reg.pmc_val = 0; /* clear all */
/* if not specified per event, then use default (could be zero: measure nothing) */
reg.pmc_plm = e[j].plm ? e[j].plm: inp->pfp_dfl_plm;
reg.pmc_oi = 1; /* overflow interrupt */
reg.pmc_pm = inp->pfp_flags & PFMLIB_PFP_SYSTEMWIDE? 1 : 0;
reg.pmc_es = generic_pe[e[j].event].pme_entry_code.pme_gen_code.pme_code;
pc[j].reg_num = assign[j];
pc[j].reg_value = reg.pmc_val;
pc[j].reg_addr = PFMLIB_GEN_IA64_PMC_BASE+j;
pd[j].reg_num = assign[j];
pd[j].reg_addr = assign[j];
__pfm_vbprintf("[PMC%u(pmc%u)=0x%lx,es=0x%02x,plm=%d pm=%d] %s\n",
assign[j],
assign[j],
reg.pmc_val,
reg.pmc_es,reg.pmc_plm,
reg.pmc_pm,
generic_pe[e[j].event].pme_name);
__pfm_vbprintf("[PMD%u(pmd%u)]\n", pd[j].reg_num, pd[j].reg_num);
}
/* number of PMC programmed */
outp->pfp_pmc_count = cnt;
outp->pfp_pmd_count = cnt;
return PFMLIB_SUCCESS;
}
