zeroshade commented on code in PR #13768:
URL: https://github.com/apache/arrow/pull/13768#discussion_r936824869


##########
go/arrow/bitutil/bitmaps.go:
##########
@@ -422,3 +423,81 @@ func CopyBitmap(src []byte, srcOffset, length int, dst 
[]byte, dstOffset int) {
        dst[nbytes-1] &= ^trailMask
        dst[nbytes-1] |= lastData & trailMask
 }
+
+type bitOp struct {
+       opWord func(uint64, uint64) uint64
+       opByte func(byte, byte) byte
+}
+
+var (
+       bitAndOp = bitOp{
+               opWord: func(l, r uint64) uint64 { return l & r },
+               opByte: func(l, r byte) byte { return l & r },
+       }
+       bitOrOp = bitOp{
+               opWord: func(l, r uint64) uint64 { return l | r },
+               opByte: func(l, r byte) byte { return l | r },
+       }
+)
+
+func alignedBitmapOp(op bitOp, left, right []byte, lOffset, rOffset int64, out 
[]byte, outOffset int64, length int64) {
+       debug.Assert(lOffset%8 == rOffset%8, "aligned bitmap op called with 
unaligned offsets")
+       debug.Assert(lOffset%8 == outOffset%8, "aligned bitmap op called with 
unaligned output offset")
+
+       nbytes := BytesForBits(length + lOffset%8)
+       left = left[lOffset/8:]
+       right = right[rOffset/8:]
+       out = out[outOffset/8:]
+       for i := int64(0); i < nbytes; i++ {
+               out[i] = op.opByte(left[i], right[i])
+       }
+}
+
+func unalignedBitmapOp(op bitOp, left, right []byte, lOffset, rOffset int64, 
out []byte, outOffset int64, length int64) {
+       leftRdr := NewBitmapWordReader(left, int(lOffset), int(length))
+       rightRdr := NewBitmapWordReader(right, int(rOffset), int(length))
+       writer := NewBitmapWordWriter(out, int(outOffset), int(length))
+
+       for nwords := leftRdr.Words(); nwords > 0; nwords-- {
+               writer.PutNextWord(op.opWord(leftRdr.NextWord(), 
rightRdr.NextWord()))

Review Comment:
   You're completely correct, `unalignedBitmapOp` is faster! i'll make some 
modifications to get the aligned one to work word-wise where it can. This might 
be a good spot to also improve the C++ implementation which would show the same 
thing (as it also works byte-wise for the aligned case)



-- 
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

To unsubscribe, e-mail: github-unsubscr...@arrow.apache.org

For queries about this service, please contact Infrastructure at:
us...@infra.apache.org

Reply via email to