XOR performance improvement via instrinics? - c

Question

I have some code where I step through two buffers and XOR one against the placing the results in a third. Specifically, this is a buffer of data, a key stream buffer, and a destination buffer.
The function in question is (in full)
static int
ssh_aes_ctr(EVP_CIPHER_CTX *ctx, u_char *dest, const u_char *src,
LIBCRYPTO_EVP_INL_TYPE len)
{
typedef union {
#ifdef CIPHER_INT128_OK
__uint128_t *u128;
#endif
uint64_t *u64;
uint32_t *u32;
uint8_t *u8;
const uint8_t *cu8;
uintptr_t u;
} ptrs_t;
ptrs_t destp, srcp, bufp;
uintptr_t align;
struct ssh_aes_ctr_ctx_mt *c;
struct kq *q, *oldq;
int ridx;
u_char *buf;
if (len == 0)
return 1;
if ((c = EVP_CIPHER_CTX_get_app_data(ctx)) == NULL)
return 0;
q = &c->q[c->qidx];
ridx = c->ridx;
/* src already padded to block multiple */
srcp.cu8 = src;
destp.u8 = dest;
do { /* do until len is 0 */
buf = q->keys[ridx];
bufp.u8 = buf;
/* figure out the alignment on the fly */
#ifdef CIPHER_UNALIGNED_OK
align = 0;
#else
align = destp.u | srcp.u | bufp.u;
#endif
/* xor the src against the key (buf)
* different systems can do all 16 bytes at once or
* may need to do it in 8 or 4 bytes chunks
* worst case is doing it as a loop */
#ifdef CIPHER_INT128_OK
if ((align & 0xf) == 0) {
destp.u128[0] = srcp.u128[0] ^ bufp.u128[0];
} else
#endif
/* 64 bits */
if ((align & 0x7) == 0) {
destp.u64[0] = srcp.u64[0] ^ bufp.u64[0];
destp.u64[1] = srcp.u64[1] ^ bufp.u64[1];
/* 32 bits */
} else if ((align & 0x3) == 0) {
destp.u32[0] = srcp.u32[0] ^ bufp.u32[0];
destp.u32[1] = srcp.u32[1] ^ bufp.u32[1];
destp.u32[2] = srcp.u32[2] ^ bufp.u32[2];
destp.u32[3] = srcp.u32[3] ^ bufp.u32[3];
} else {
/*1 byte at a time*/
size_t i;
for (i = 0; i < AES_BLOCK_SIZE; ++i)
dest[i] = src[i] ^ buf[i];
}
/* inc/decrement the pointers by the block size (16)*/
destp.u += AES_BLOCK_SIZE;
srcp.u += AES_BLOCK_SIZE;
/* Increment read index, switch queues on rollover */
if ((ridx = (ridx + 1) % KQLEN) == 0) {
oldq = q;
/* Mark next queue draining, may need to wait */
c->qidx = (c->qidx + 1) % numkq;
q = &c->q[c->qidx];
pthread_mutex_lock(&q->lock);
while (q->qstate != KQFULL) {
pthread_cond_wait(&q->cond, &q->lock);
}
q->qstate = KQDRAINING;
pthread_cond_broadcast(&q->cond);
pthread_mutex_unlock(&q->lock);
/* Mark consumed queue empty and signal producers */
pthread_mutex_lock(&oldq->lock);
oldq->qstate = KQEMPTY;
pthread_cond_broadcast(&oldq->cond);
pthread_mutex_unlock(&oldq->lock);
}
} while (len -= AES_BLOCK_SIZE);
c->ridx = ridx;
return 1;
}
Running this through vtune I find that the destp.u128[0] = srcp.u128[0] ^ bufp.u128[0]; line consumes 4% of the cpu time.
The assembly for this line is
shl $0x4, %rax
addq (%rsp), %rax
movq (%rax), %rdx
xorq (%rbx), %rdx
movq 0x8(%rax), %rax
xorq 0x8(%rax), %rax
movq %rax, 0x8(%r12)
The xorq (%rbx), %rdx is consuming 3.5% of the CPU time. What I am wondering is if I could improve performance by vectorizing the data being xor'd and then using intrinsics to perform the xor. I don't have much (read any) real experience in using intrinsics but I'm willing to learn. I just don't know if this code, as is, is about as good as I can expect. Any pointers would be appreciated.
Thanks