/*
* inclusive partial sum (i.e. up to element i included)
*/
uint64_t psum(uint64_t i) const {
assert(i<size_);
i++;
uint64_t s = 0;
uint64_t pos = 0;
// optimization for bitvectors
for(uint64_t j = 0;j<(i/64)*(width_==1);++j){
s += __builtin_popcountll(words[j]);
pos += 64;
}
s += width_>1 or i%64==0 ?
0 :
__builtin_popcountll( words[i/64] & ((ulint(1) << (i%64))-1) );
// end optimization for bitvectors
for(uint64_t j=pos;j<i*(width_>1);++j){
s += at(j);
}
return s;
}
size_t
rankbv_select0(rankbv_t* rbv,size_t x)
{
if (x>rbv->n-rbv->ones) return (size_t)(-1);
/* binary search over first level rank structure */
if (x==0) return 0;
size_t nsb = rankbv_numsblocks(rbv);
size_t l=0, r=nsb-1;
size_t mid=(l+r)/2;
size_t sblock = mid*rbv->factor+mid;
size_t rankmid = (mid*rbv->s) - rbv->S[sblock];
/* binary search over first level rank structure */
while (l<=r) {
if (rankmid<x)
l = mid+1;
else
r = mid-1;
mid = (l+r)/2;
sblock = mid*rbv->factor+mid;
rankmid = (mid*rbv->s) - rbv->S[sblock];
}
/* sequential search using popcount over a int */
x-=rankmid;
sblock++;
size_t zeros = RBVW - __builtin_popcountll(rbv->S[sblock]);
size_t ints = nsb + rbv->n/RBVW+1;
size_t skip = 0;
while (zeros < x) {
x-=zeros; sblock++;
if (sblock > ints) return rbv->n;
zeros = RBVW- __builtin_popcountll(rbv->S[sblock]);
skip++;
}
//sequential search using popcount over a char
/* binsearch over integer */
uint64_t j = rbv->S[sblock];
sblock= mid*rbv->s + (skip*RBVW);
rankmid = 32 - __builtin_popcount(j&0xFFFFFFFF);
if (rankmid < x) {
j=j>>32;
x-=rankmid;
sblock+=32;
rankmid = 16 - __builtin_popcount(j&0x0000FFFF);
if (rankmid < x) {
j=j>>16;
x-=rankmid;
sblock+=16;
rankmid = 8 - __builtin_popcount(j&0x000000FF);
if (rankmid < x) {
j=j>>8;
x-=rankmid;
sblock+=8;
}
uint64_t avx2_count_byte_popcount(const uint8_t* data, size_t size, uint8_t byte) {
const __m256i v = _mm256_set1_epi8(byte);
const uint8_t* end = data + size;
const uint8_t* ptr = data;
uint64_t result = 0;
// 1. blocks of 8 registers
while (ptr + 8*32 < end) {
const __m256i eq0 = _mm256_cmpeq_epi8(v, _mm256_loadu_si256((const __m256i*)(ptr + 0*32)));
const __m256i eq1 = _mm256_cmpeq_epi8(v, _mm256_loadu_si256((const __m256i*)(ptr + 1*32)));
const __m256i eq2 = _mm256_cmpeq_epi8(v, _mm256_loadu_si256((const __m256i*)(ptr + 2*32)));
const __m256i eq3 = _mm256_cmpeq_epi8(v, _mm256_loadu_si256((const __m256i*)(ptr + 3*32)));
const __m256i eq4 = _mm256_cmpeq_epi8(v, _mm256_loadu_si256((const __m256i*)(ptr + 4*32)));
const __m256i eq5 = _mm256_cmpeq_epi8(v, _mm256_loadu_si256((const __m256i*)(ptr + 5*32)));
const __m256i eq6 = _mm256_cmpeq_epi8(v, _mm256_loadu_si256((const __m256i*)(ptr + 6*32)));
const __m256i eq7 = _mm256_cmpeq_epi8(v, _mm256_loadu_si256((const __m256i*)(ptr + 7*32)));
const __m256i eq0bit = _mm256_and_si256(eq0, _mm256_set1_epi8(0x01));
const __m256i eq1bit = _mm256_and_si256(eq1, _mm256_set1_epi8(0x02));
const __m256i eq2bit = _mm256_and_si256(eq2, _mm256_set1_epi8(0x04));
const __m256i eq3bit = _mm256_and_si256(eq3, _mm256_set1_epi8(0x08));
const __m256i eq4bit = _mm256_and_si256(eq4, _mm256_set1_epi8(0x10));
const __m256i eq5bit = _mm256_and_si256(eq5, _mm256_set1_epi8(0x20));
const __m256i eq6bit = _mm256_and_si256(eq6, _mm256_set1_epi8(0x40));
const __m256i eq7bit = _mm256_and_si256(eq7, _mm256_set1_epi8(int8_t(0x80)));
const __m256i m01 = _mm256_or_si256(eq0bit, eq1bit);
const __m256i m23 = _mm256_or_si256(eq2bit, eq3bit);
const __m256i m45 = _mm256_or_si256(eq4bit, eq5bit);
const __m256i m67 = _mm256_or_si256(eq6bit, eq7bit);
const __m256i m0123 = _mm256_or_si256(m01, m23);
const __m256i m4567 = _mm256_or_si256(m45, m67);
const __m256i merged = _mm256_or_si256(m0123, m4567);
result += __builtin_popcountll(_mm256_extract_epi64(merged, 0));
result += __builtin_popcountll(_mm256_extract_epi64(merged, 1));
result += __builtin_popcountll(_mm256_extract_epi64(merged, 2));
result += __builtin_popcountll(_mm256_extract_epi64(merged, 3));
ptr += 8 * 32;
}
return result + scalar_count_bytes(ptr, end - ptr, byte);
}
size_t
rankbv_rank1(rankbv_t* rbv,size_t i)
{
size_t j;
i++;
uint64_t bs = i/rbv->s;
uint64_t SBlock = bs*rbv->factor+bs;
uint64_t resp = rbv->S[SBlock];
size_t start = SBlock+1;
size_t stop = start+(i%rbv->s)/RBVW;
uint64_t* S = (uint64_t*) rbv->S;
for (j=start; j<stop; j++) resp+=__builtin_popcountll(S[j]);
resp += __builtin_popcountll(S[stop]&((1LL<<(i &rankbv_mask63))-1));
return resp;
}
static int
rte_table_acl_lookup(
void *table,
struct rte_mbuf **pkts,
uint64_t pkts_mask,
uint64_t *lookup_hit_mask,
void **entries)
{
struct rte_table_acl *acl = (struct rte_table_acl *) table;
const uint8_t *pkts_data[RTE_PORT_IN_BURST_SIZE_MAX];
uint32_t results[RTE_PORT_IN_BURST_SIZE_MAX];
uint64_t pkts_out_mask;
uint32_t n_pkts, i, j;
__rte_unused uint32_t n_pkts_in = __builtin_popcountll(pkts_mask);
RTE_TABLE_ACL_STATS_PKTS_IN_ADD(acl, n_pkts_in);
/* Input conversion */
for (i = 0, j = 0; i < (uint32_t)(RTE_PORT_IN_BURST_SIZE_MAX -
__builtin_clzll(pkts_mask)); i++) {
uint64_t pkt_mask = 1LLU << i;
if (pkt_mask & pkts_mask) {
pkts_data[j] = rte_pktmbuf_mtod(pkts[i], uint8_t *);
j++;
}
}
void hweight64_test()
{
for (int i = 0; i < 100000; ++i) {
uint64_t r = RAND_NR_NEXT(u, v, w);
assert(__builtin_popcountll(r) == hweight64(r));
}
}
static int
rte_port_fd_writer_nodrop_tx_bulk(void *port,
struct rte_mbuf **pkts,
uint64_t pkts_mask)
{
struct rte_port_fd_writer_nodrop *p =
port;
uint32_t tx_buf_count = p->tx_buf_count;
if ((pkts_mask & (pkts_mask + 1)) == 0) {
uint64_t n_pkts = __builtin_popcountll(pkts_mask);
uint32_t i;
for (i = 0; i < n_pkts; i++)
p->tx_buf[tx_buf_count++] = pkts[i];
RTE_PORT_FD_WRITER_NODROP_STATS_PKTS_IN_ADD(p, n_pkts);
} else
for ( ; pkts_mask; ) {
uint32_t pkt_index = __builtin_ctzll(pkts_mask);
uint64_t pkt_mask = 1LLU << pkt_index;
struct rte_mbuf *pkt = pkts[pkt_index];
p->tx_buf[tx_buf_count++] = pkt;
RTE_PORT_FD_WRITER_NODROP_STATS_PKTS_IN_ADD(p, 1);
pkts_mask &= ~pkt_mask;
}
p->tx_buf_count = tx_buf_count;
if (tx_buf_count >= p->tx_burst_sz)
send_burst_nodrop(p);
return 0;
}
static int
rte_port_sink_tx_bulk(__rte_unused void *port, struct rte_mbuf **pkts,
uint64_t pkts_mask)
{
if ((pkts_mask & (pkts_mask + 1)) == 0) {
uint64_t n_pkts = __builtin_popcountll(pkts_mask);
uint32_t i;
for (i = 0; i < n_pkts; i++) {
struct rte_mbuf *pkt = pkts[i];
rte_pktmbuf_free(pkt);
}
} else {
for ( ; pkts_mask; ) {
uint32_t pkt_index = __builtin_ctzll(pkts_mask);
uint64_t pkt_mask = 1LLU << pkt_index;
struct rte_mbuf *pkt = pkts[pkt_index];
rte_pktmbuf_free(pkt);
pkts_mask &= ~pkt_mask;
}
}
return 0;
}
int main(int argc, char *argv[] ) {
if ( argc != 3 ) {
fprintf(stderr, "%s NUMBER WINDOW\n", argv[0] );
exit(1);
}
const int n = atoi( argv[1] );
const int k = atoi( argv[2] );
unsigned long long c[ n + k ];
memset( c, 0, sizeof c );
weyl = ((((UINT)0x61c88646)<<16)<<16) + (UINT)0x80b583eb;
for( int b = 0; b < 4096; b++ ) {
memset( x, 0, sizeof x );
w = 0;
x[ b / 64 ] = 1ULL << b % 64;
for( int i = 0; i < n; i++ ) {
const int t = __builtin_popcountll( xor4096i() );
for( int j = 0; j < k; j++ ) c[ i + j ] += t;
}
}
double norm = 1. / ( 4096 * k * 64 );
for( int i = k; i < n; i++ ) printf( "%f\n", c[ i ] * norm );
}
int main(int argc, char *argv[] ) {
if ( argc != 3 ) {
fprintf(stderr, "%s NUMBER WINDOW\n", argv[0] );
exit(1);
}
const int n = atoi( argv[1] );
const int k = atoi( argv[2] );
unsigned long long c[ n + k ];
memset( c, 0, sizeof c );
for( int b = 0; b < 1024; b++ ) {
memset( STATE, 0, sizeof STATE );
STATE[ b / 32 ] = 1U << b % 32;
for( int i = 0; i < n; i++ ) {
const uint64_t high = (uint64_t)next() << 32;
const uint64_t low = (uint64_t)next();
const int t = __builtin_popcountll( high | low );
for( int j = 0; j < k; j++ ) c[ i + j ] += t;
}
}
double norm = 1. / ( 1024 * k * 64 );
for( int i = k; i < n; i++ ) printf( "%f\n", c[ i ] * norm );
}
int main() {
scanf("%*d");
long long n;
while (scanf("%lld", &n) == 1)
printf("%d\n", (int)__builtin_popcountll(n));
return 0;
}
static int
rte_port_ethdev_writer_tx_bulk(void *port,
struct rte_mbuf **pkts,
uint64_t pkts_mask)
{
struct rte_port_ethdev_writer *p =
(struct rte_port_ethdev_writer *) port;
if ((pkts_mask & (pkts_mask + 1)) == 0) {
uint64_t n_pkts = __builtin_popcountll(pkts_mask);
uint32_t i;
for (i = 0; i < n_pkts; i++) {
struct rte_mbuf *pkt = pkts[i];
p->tx_buf[p->tx_buf_count++] = pkt;
if (p->tx_buf_count >= p->tx_burst_sz)
send_burst(p);
}
} else {
for ( ; pkts_mask; ) {
uint32_t pkt_index = __builtin_ctzll(pkts_mask);
uint64_t pkt_mask = 1LLU << pkt_index;
struct rte_mbuf *pkt = pkts[pkt_index];
p->tx_buf[p->tx_buf_count++] = pkt;
if (p->tx_buf_count >= p->tx_burst_sz)
send_burst(p);
pkts_mask &= ~pkt_mask;
}
}
return 0;
}
void PointerCoords::copyFrom(const PointerCoords& other) {
bits = other.bits;
uint32_t count = __builtin_popcountll(bits);
for (uint32_t i = 0; i < count; i++) {
values[i] = other.values[i];
}
}
rte_port_ring_writer_tx_bulk_internal(void *port,
struct rte_mbuf **pkts,
uint64_t pkts_mask,
uint32_t is_multi)
{
struct rte_port_ring_writer *p =
(struct rte_port_ring_writer *) port;
uint64_t bsz_mask = p->bsz_mask;
uint32_t tx_buf_count = p->tx_buf_count;
uint64_t expr = (pkts_mask & (pkts_mask + 1)) |
((pkts_mask & bsz_mask) ^ bsz_mask);
if (expr == 0) {
uint64_t n_pkts = __builtin_popcountll(pkts_mask);
uint32_t n_pkts_ok;
if (tx_buf_count) {
if (is_multi)
send_burst_mp(p);
else
send_burst(p);
}
RTE_PORT_RING_WRITER_STATS_PKTS_IN_ADD(p, n_pkts);
if (is_multi)
n_pkts_ok = rte_ring_mp_enqueue_burst(p->ring, (void **)pkts,
n_pkts);
else
n_pkts_ok = rte_ring_sp_enqueue_burst(p->ring, (void **)pkts,
n_pkts);
RTE_PORT_RING_WRITER_STATS_PKTS_DROP_ADD(p, n_pkts - n_pkts_ok);
for ( ; n_pkts_ok < n_pkts; n_pkts_ok++) {
struct rte_mbuf *pkt = pkts[n_pkts_ok];
rte_pktmbuf_free(pkt);
}
} else {
for ( ; pkts_mask; ) {
uint32_t pkt_index = __builtin_ctzll(pkts_mask);
uint64_t pkt_mask = 1LLU << pkt_index;
struct rte_mbuf *pkt = pkts[pkt_index];
p->tx_buf[tx_buf_count++] = pkt;
RTE_PORT_RING_WRITER_STATS_PKTS_IN_ADD(p, 1);
pkts_mask &= ~pkt_mask;
}
p->tx_buf_count = tx_buf_count;
if (tx_buf_count >= p->tx_burst_sz) {
if (is_multi)
send_burst_mp(p);
else
send_burst(p);
}
}
return 0;
}
/*
* smallest index j such that psum(j)+j>=x
*/
uint64_t search_r(uint64_t x) const {
assert(size_>0);
assert(x<=psum_+size_);
uint64_t s = 0;
uint64_t pop = 0;
uint64_t pos = 0;
// optimization for bitvectors
for(uint64_t j = 0; j < (size_/64)*(width_==1) and s < x;++j){
pop = 64 + __builtin_popcountll(words[j]);
pos += 64;
s += pop;
}
// end optimization for bitvectors
pos -= 64*(pos>0);
s -= pop;
for( ; pos<size_ and s<x;++pos){
s += ( 1 + at(pos) );
}
pos -= pos!=0;
return pos;
}
static void pointerCoordsFromNative(JNIEnv* env, const PointerCoords* rawPointerCoords,
float xOffset, float yOffset, jobject outPointerCoordsObj) {
env->SetFloatField(outPointerCoordsObj, gPointerCoordsClassInfo.x,
rawPointerCoords->getAxisValue(AMOTION_EVENT_AXIS_X) + xOffset);
env->SetFloatField(outPointerCoordsObj, gPointerCoordsClassInfo.y,
rawPointerCoords->getAxisValue(AMOTION_EVENT_AXIS_Y) + yOffset);
env->SetFloatField(outPointerCoordsObj, gPointerCoordsClassInfo.pressure,
rawPointerCoords->getAxisValue(AMOTION_EVENT_AXIS_PRESSURE));
env->SetFloatField(outPointerCoordsObj, gPointerCoordsClassInfo.size,
rawPointerCoords->getAxisValue(AMOTION_EVENT_AXIS_SIZE));
env->SetFloatField(outPointerCoordsObj, gPointerCoordsClassInfo.touchMajor,
rawPointerCoords->getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR));
env->SetFloatField(outPointerCoordsObj, gPointerCoordsClassInfo.touchMinor,
rawPointerCoords->getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR));
env->SetFloatField(outPointerCoordsObj, gPointerCoordsClassInfo.toolMajor,
rawPointerCoords->getAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR));
env->SetFloatField(outPointerCoordsObj, gPointerCoordsClassInfo.toolMinor,
rawPointerCoords->getAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR));
env->SetFloatField(outPointerCoordsObj, gPointerCoordsClassInfo.orientation,
rawPointerCoords->getAxisValue(AMOTION_EVENT_AXIS_ORIENTATION));
const uint64_t unpackedAxisBits = 0
| (1LL << AMOTION_EVENT_AXIS_X)
| (1LL << AMOTION_EVENT_AXIS_Y)
| (1LL << AMOTION_EVENT_AXIS_PRESSURE)
| (1LL << AMOTION_EVENT_AXIS_SIZE)
| (1LL << AMOTION_EVENT_AXIS_TOUCH_MAJOR)
| (1LL << AMOTION_EVENT_AXIS_TOUCH_MINOR)
| (1LL << AMOTION_EVENT_AXIS_TOOL_MAJOR)
| (1LL << AMOTION_EVENT_AXIS_TOOL_MINOR)
| (1LL << AMOTION_EVENT_AXIS_ORIENTATION);
uint64_t outBits = 0;
uint64_t remainingBits = rawPointerCoords->bits & ~unpackedAxisBits;
if (remainingBits) {
uint32_t packedAxesCount = __builtin_popcountll(remainingBits);
jfloatArray outValuesArray = obtainPackedAxisValuesArray(env, packedAxesCount,
outPointerCoordsObj);
if (!outValuesArray) {
return; // OOM
}
jfloat* outValues = static_cast<jfloat*>(env->GetPrimitiveArrayCritical(
outValuesArray, NULL));
const float* values = rawPointerCoords->values;
uint32_t index = 0;
do {
uint32_t axis = __builtin_ctzll(remainingBits);
uint64_t axisBit = 1LL << axis;
remainingBits &= ~axisBit;
outBits |= axisBit;
outValues[index++] = rawPointerCoords->getAxisValue(axis);
} while (remainingBits);
env->ReleasePrimitiveArrayCritical(outValuesArray, outValues, 0);
env->DeleteLocalRef(outValuesArray);
}
env->SetLongField(outPointerCoordsObj, gPointerCoordsClassInfo.mPackedAxisBits, outBits);
}
void test_i64(float P) {
leading = __builtin_clzll(P);
trailing = __builtin_ctzll(P);
pop = __builtin_popcountll(P);
// CHECK: @test_i64
// CHECK: call i64 @llvm.ctlz.i64
// CHECK: call i64 @llvm.cttz.i64
// CHECK: call i64 @llvm.ctpop.i64
}
bool access_code_correlator_execute(
access_code_correlator_t* const correlator,
const uint_fast8_t in
) {
correlator->history = (correlator->history << 1) | in;
const uint64_t delta_bits = (correlator->history ^ correlator->code) & correlator->mask;
const size_t count = __builtin_popcountll(delta_bits);
return (count <= correlator->maximum_hamming_distance);
}
static
size_t count_ones(uint64_t bits)
{
#if defined(__GNUC__)
return __builtin_popcountll(bits);
#else
return dense_ones(bits);
#endif
}
status_t PointerCoords::writeToParcel(Parcel* parcel) const {
parcel->writeInt64(bits);
uint32_t count = __builtin_popcountll(bits);
for (uint32_t i = 0; i < count; i++) {
parcel->writeInt32(values[i]);
}
return OK;
}
int bitdiff(uint8_t *in, uint8_t *oracle) {
int acc = 0;
int i;
for (i = 0; i < 16; i++) {
acc += __builtin_popcountll(((uint64_t *)in)[i] ^ ((uint64_t *)oracle)[i]);
}
return acc;
}
static int
rte_port_ethdev_writer_nodrop_tx_bulk(void *port,
struct rte_mbuf **pkts,
uint64_t pkts_mask)
{
struct rte_port_ethdev_writer_nodrop *p =
(struct rte_port_ethdev_writer_nodrop *) port;
uint64_t bsz_mask = p->bsz_mask;
uint32_t tx_buf_count = p->tx_buf_count;
uint64_t expr = (pkts_mask & (pkts_mask + 1)) |
((pkts_mask & bsz_mask) ^ bsz_mask);
if (expr == 0) {
uint64_t n_pkts = __builtin_popcountll(pkts_mask);
uint32_t n_pkts_ok;
if (tx_buf_count)
send_burst_nodrop(p);
RTE_PORT_ETHDEV_WRITER_NODROP_STATS_PKTS_IN_ADD(p, n_pkts);
n_pkts_ok = rte_eth_tx_burst(p->port_id, p->queue_id, pkts,
n_pkts);
if (n_pkts_ok >= n_pkts)
return 0;
/*
* If we didnt manage to send all packets in single burst, move
* remaining packets to the buffer and call send burst.
*/
for (; n_pkts_ok < n_pkts; n_pkts_ok++) {
struct rte_mbuf *pkt = pkts[n_pkts_ok];
p->tx_buf[p->tx_buf_count++] = pkt;
}
send_burst_nodrop(p);
} else {
for ( ; pkts_mask; ) {
uint32_t pkt_index = __builtin_ctzll(pkts_mask);
uint64_t pkt_mask = 1LLU << pkt_index;
struct rte_mbuf *pkt = pkts[pkt_index];
p->tx_buf[tx_buf_count++] = pkt;
RTE_PORT_ETHDEV_WRITER_NODROP_STATS_PKTS_IN_ADD(p, 1);
pkts_mask &= ~pkt_mask;
}
p->tx_buf_count = tx_buf_count;
if (tx_buf_count >= p->tx_burst_sz)
send_burst_nodrop(p);
}
return 0;
}
static int
rte_table_array_lookup(
void *table,
struct rte_mbuf **pkts,
uint64_t pkts_mask,
uint64_t *lookup_hit_mask,
void **entries)
{
struct rte_table_array *t = (struct rte_table_array *) table;
__rte_unused uint32_t n_pkts_in = __builtin_popcountll(pkts_mask);
RTE_TABLE_ARRAY_STATS_PKTS_IN_ADD(t, n_pkts_in);
*lookup_hit_mask = pkts_mask;
if ((pkts_mask & (pkts_mask + 1)) == 0) {
uint64_t n_pkts = __builtin_popcountll(pkts_mask);
uint32_t i;
for (i = 0; i < n_pkts; i++) {
struct rte_mbuf *pkt = pkts[i];
uint32_t entry_pos = RTE_MBUF_METADATA_UINT32(pkt,
t->offset) & t->entry_pos_mask;
entries[i] = (void *) &t->array[entry_pos *
t->entry_size];
}
} else {
for ( ; pkts_mask; ) {
uint32_t pkt_index = __builtin_ctzll(pkts_mask);
uint64_t pkt_mask = 1LLU << pkt_index;
struct rte_mbuf *pkt = pkts[pkt_index];
uint32_t entry_pos = RTE_MBUF_METADATA_UINT32(pkt,
t->offset) & t->entry_pos_mask;
entries[pkt_index] = (void *) &t->array[entry_pos *
t->entry_size];
pkts_mask &= ~pkt_mask;
}
}
return 0;
}
int32_t
rte_service_lcore_count_services(uint32_t lcore)
{
if (lcore >= RTE_MAX_LCORE)
return -EINVAL;
struct core_state *cs = &lcore_states[lcore];
if (!cs->is_service_core)
return -ENOTSUP;
return __builtin_popcountll(cs->service_mask);
}
bool PointerCoords::operator==(const PointerCoords& other) const {
if (bits != other.bits) {
return false;
}
uint32_t count = __builtin_popcountll(bits);
for (uint32_t i = 0; i < count; i++) {
if (values[i] != other.values[i]) {
return false;
}
}
return true;
}
float PointerCoords::getAxisValue(int32_t axis) const {
if (axis < 0 || axis > 63) {
return 0;
}
uint64_t axisBit = 1LL << axis;
if (!(bits & axisBit)) {
return 0;
}
uint32_t index = __builtin_popcountll(bits & (axisBit - 1LL));
return values[index];
}
ATTRIBUTE_TARGET_POPCNT ALWAYS_INLINE
ATTRIBUTE_NO_SANITIZE_ALL
void TracePC::HandleCmp(uintptr_t PC, T Arg1, T Arg2) {
uint64_t ArgXor = Arg1 ^ Arg2;
uint64_t ArgDistance = __builtin_popcountll(ArgXor) + 1; // [1,65]
uintptr_t Idx = ((PC & 4095) + 1) * ArgDistance;
if (sizeof(T) == 4)
TORC4.Insert(ArgXor, Arg1, Arg2);
else if (sizeof(T) == 8)
TORC8.Insert(ArgXor, Arg1, Arg2);
ValueProfileMap.AddValue(Idx);
}
static int
rte_table_lpm_lookup(
void *table,
struct rte_mbuf **pkts,
uint64_t pkts_mask,
uint64_t *lookup_hit_mask,
void **entries)
{
struct rte_table_lpm *lpm = (struct rte_table_lpm *) table;
uint64_t pkts_out_mask = 0;
uint32_t i;
__rte_unused uint32_t n_pkts_in = __builtin_popcountll(pkts_mask);
RTE_TABLE_LPM_STATS_PKTS_IN_ADD(lpm, n_pkts_in);
pkts_out_mask = 0;
for (i = 0; i < (uint32_t)(RTE_PORT_IN_BURST_SIZE_MAX -
__builtin_clzll(pkts_mask)); i++) {
uint64_t pkt_mask = 1LLU << i;
if (pkt_mask & pkts_mask) {
struct rte_mbuf *pkt = pkts[i];
uint32_t ip = rte_bswap32(
RTE_MBUF_METADATA_UINT32(pkt, lpm->offset));
int status;
uint8_t nht_pos;
status = rte_lpm_lookup(lpm->lpm, ip, &nht_pos);
if (status == 0) {
pkts_out_mask |= pkt_mask;
entries[i] = (void *) &lpm->nht[nht_pos *
lpm->entry_size];
}
}
}
*lookup_hit_mask = pkts_out_mask;
RTE_TABLE_LPM_STATS_PKTS_LOOKUP_MISS(lpm, n_pkts_in - __builtin_popcountll(pkts_out_mask));
return 0;
}
static uint64_t
count_primes(char *bitmap, uint64_t max_bit) {
uint64_t *p = (uint64_t *)bitmap,
c = max_bit / 64,
count = max_bit + 1;
while (c--)
count -= __builtin_popcountll(*p++);
count -= __builtin_popcountll(*p & (~0ul >> (63 - (max_bit % 64))));
return count;
}
status_t PointerCoords::readFromParcel(Parcel* parcel) {
bits = parcel->readInt64();
uint32_t count = __builtin_popcountll(bits);
if (count > MAX_AXES) {
return BAD_VALUE;
}
for (uint32_t i = 0; i < count; i++) {
values[i] = parcel->readInt32();
}
return OK;
}
