summaryrefslogtreecommitdiff
path: root/Aesthetic-changes-to-PR.patch
diff options
context:
space:
mode:
Diffstat (limited to 'Aesthetic-changes-to-PR.patch')
-rw-r--r--Aesthetic-changes-to-PR.patch185
1 files changed, 185 insertions, 0 deletions
diff --git a/Aesthetic-changes-to-PR.patch b/Aesthetic-changes-to-PR.patch
new file mode 100644
index 0000000..77e848e
--- /dev/null
+++ b/Aesthetic-changes-to-PR.patch
@@ -0,0 +1,185 @@
+From 7413dc16572ffd672835c1391b08409472771093 Mon Sep 17 00:00:00 2001
+From: antirez <antirez@gmail.com>
+Date: Fri, 16 Mar 2018 16:57:53 +0100
+Subject: [PATCH] Aesthetic changes to PR #4749.
+
+---
+ src/hyperloglog.c | 80 +++++++++++++++++++++++------------------------
+ 1 file changed, 40 insertions(+), 40 deletions(-)
+
+diff --git a/src/hyperloglog.c b/src/hyperloglog.c
+index 77109c8..68d591c 100644
+--- a/src/hyperloglog.c
++++ b/src/hyperloglog.c
+@@ -403,7 +403,7 @@ uint64_t MurmurHash64A (const void * key, int len, unsigned int seed) {
+
+ #if (BYTE_ORDER == LITTLE_ENDIAN)
+ #ifdef USE_ALIGNED_ACCESS
+- memcpy(&k,data,sizeof(uint64_t));
++ memcpy(&k,data,sizeof(uint64_t));
+ #else
+ k = *((uint64_t*)data);
+ #endif
+@@ -512,7 +512,7 @@ int hllDenseAdd(uint8_t *registers, unsigned char *ele, size_t elesize) {
+ }
+
+ /* Compute the register histogram in the dense representation. */
+-void hllDenseRegHisto(uint8_t *registers, int* regHisto) {
++void hllDenseRegHisto(uint8_t *registers, int* reghisto) {
+ int j;
+
+ /* Redis default is to use 16384 registers 6 bits each. The code works
+@@ -541,22 +541,22 @@ void hllDenseRegHisto(uint8_t *registers, int* regHisto) {
+ r14 = (r[10] >> 4 | r[11] << 4) & 63;
+ r15 = (r[11] >> 2) & 63;
+
+- regHisto[r0] += 1;
+- regHisto[r1] += 1;
+- regHisto[r2] += 1;
+- regHisto[r3] += 1;
+- regHisto[r4] += 1;
+- regHisto[r5] += 1;
+- regHisto[r6] += 1;
+- regHisto[r7] += 1;
+- regHisto[r8] += 1;
+- regHisto[r9] += 1;
+- regHisto[r10] += 1;
+- regHisto[r11] += 1;
+- regHisto[r12] += 1;
+- regHisto[r13] += 1;
+- regHisto[r14] += 1;
+- regHisto[r15] += 1;
++ reghisto[r0]++;
++ reghisto[r1]++;
++ reghisto[r2]++;
++ reghisto[r3]++;
++ reghisto[r4]++;
++ reghisto[r5]++;
++ reghisto[r6]++;
++ reghisto[r7]++;
++ reghisto[r8]++;
++ reghisto[r9]++;
++ reghisto[r10]++;
++ reghisto[r11]++;
++ reghisto[r12]++;
++ reghisto[r13]++;
++ reghisto[r14]++;
++ reghisto[r15]++;
+
+ r += 12;
+ }
+@@ -564,7 +564,7 @@ void hllDenseRegHisto(uint8_t *registers, int* regHisto) {
+ for(j = 0; j < HLL_REGISTERS; j++) {
+ unsigned long reg;
+ HLL_DENSE_GET_REGISTER(reg,registers,j);
+- regHisto[reg] += 1;
++ reghisto[reg]++;
+ }
+ }
+ }
+@@ -904,7 +904,7 @@ int hllSparseAdd(robj *o, unsigned char *ele, size_t elesize) {
+ }
+
+ /* Compute the register histogram in the sparse representation. */
+-void hllSparseRegHisto(uint8_t *sparse, int sparselen, int *invalid, int* regHisto) {
++void hllSparseRegHisto(uint8_t *sparse, int sparselen, int *invalid, int* reghisto) {
+ int idx = 0, runlen, regval;
+ uint8_t *end = sparse+sparselen, *p = sparse;
+
+@@ -912,18 +912,18 @@ void hllSparseRegHisto(uint8_t *sparse, int sparselen, int *invalid, int* regHis
+ if (HLL_SPARSE_IS_ZERO(p)) {
+ runlen = HLL_SPARSE_ZERO_LEN(p);
+ idx += runlen;
+- regHisto[0] += runlen;
++ reghisto[0] += runlen;
+ p++;
+ } else if (HLL_SPARSE_IS_XZERO(p)) {
+ runlen = HLL_SPARSE_XZERO_LEN(p);
+ idx += runlen;
+- regHisto[0] += runlen;
++ reghisto[0] += runlen;
+ p += 2;
+ } else {
+ runlen = HLL_SPARSE_VAL_LEN(p);
+ regval = HLL_SPARSE_VAL_VALUE(p);
+ idx += runlen;
+- regHisto[regval] += runlen;
++ reghisto[regval] += runlen;
+ p++;
+ }
+ }
+@@ -938,24 +938,24 @@ void hllSparseRegHisto(uint8_t *sparse, int sparselen, int *invalid, int* regHis
+
+ /* Implements the register histogram calculation for uint8_t data type
+ * which is only used internally as speedup for PFCOUNT with multiple keys. */
+-void hllRawRegHisto(uint8_t *registers, int* regHisto) {
++void hllRawRegHisto(uint8_t *registers, int* reghisto) {
+ uint64_t *word = (uint64_t*) registers;
+ uint8_t *bytes;
+ int j;
+
+ for (j = 0; j < HLL_REGISTERS/8; j++) {
+ if (*word == 0) {
+- regHisto[0] += 8;
++ reghisto[0] += 8;
+ } else {
+ bytes = (uint8_t*) word;
+- regHisto[bytes[0]] += 1;
+- regHisto[bytes[1]] += 1;
+- regHisto[bytes[2]] += 1;
+- regHisto[bytes[3]] += 1;
+- regHisto[bytes[4]] += 1;
+- regHisto[bytes[5]] += 1;
+- regHisto[bytes[6]] += 1;
+- regHisto[bytes[7]] += 1;
++ reghisto[bytes[0]]++;
++ reghisto[bytes[1]]++;
++ reghisto[bytes[2]]++;
++ reghisto[bytes[3]]++;
++ reghisto[bytes[4]]++;
++ reghisto[bytes[5]]++;
++ reghisto[bytes[6]]++;
++ reghisto[bytes[7]]++;
+ }
+ word++;
+ }
+@@ -1011,16 +1011,16 @@ uint64_t hllCount(struct hllhdr *hdr, int *invalid) {
+ double E;
+ int j;
+ double alphaInf = 0.5 / log(2.);
+- int regHisto[HLL_Q+2] = {0};
++ int reghisto[HLL_Q+2] = {0};
+
+ /* Compute register histogram */
+ if (hdr->encoding == HLL_DENSE) {
+- hllDenseRegHisto(hdr->registers,regHisto);
++ hllDenseRegHisto(hdr->registers,reghisto);
+ } else if (hdr->encoding == HLL_SPARSE) {
+ hllSparseRegHisto(hdr->registers,
+- sdslen((sds)hdr)-HLL_HDR_SIZE,invalid,regHisto);
++ sdslen((sds)hdr)-HLL_HDR_SIZE,invalid,reghisto);
+ } else if (hdr->encoding == HLL_RAW) {
+- hllRawRegHisto(hdr->registers,regHisto);
++ hllRawRegHisto(hdr->registers,reghisto);
+ } else {
+ serverPanic("Unknown HyperLogLog encoding in hllCount()");
+ }
+@@ -1028,12 +1028,12 @@ uint64_t hllCount(struct hllhdr *hdr, int *invalid) {
+ /* Estimate cardinality form register histogram. See:
+ * "New cardinality estimation algorithms for HyperLogLog sketches"
+ * Otmar Ertl, arXiv:1702.01284 */
+- double z = m * hllTau((m-regHisto[HLL_Q+1])/(double)m);
++ double z = m * hllTau((m-reghisto[HLL_Q+1])/(double)m);
+ for (j = HLL_Q; j >= 1; --j) {
+- z += regHisto[j];
++ z += reghisto[j];
+ z *= 0.5;
+ }
+- z += m * hllSigma(regHisto[0]/(double)m);
++ z += m * hllSigma(reghisto[0]/(double)m);
+ E = llroundl(alphaInf*m*m/z);
+
+ return (uint64_t) E;
+--
+2.23.0
+
generated by cgit v1.2.3 (git 2.25.1) at 2025-06-25 14:59:07 +0000