获取指定长度的已分配内存空间的一部分

Question

我使用malloc()加载到RAM中的数十亿比特 - 将其称为big_set。我还有另外一些位（将它称为small_set）在RAM中，它们都被设置为1，我知道它的大小（多少位 - 我会称它为ss_size），但无法预测它，因为每次执行都不相同。 ss_size有时可能小到100或大到数亿。

我需要做的small_set和一些不可预知的部分ss_size的big_set位长度之间的一些位操作。我不能只是扩大small_set在最重要和最不重要的一面都用零来使它的大小等于big_set的大小，因为这将非常昂贵的RAM和CPU（相同的操作将在相同时间有很多不同的大小small_set s，并且还将通过small_set进行移位操作，扩展它将导致CPU在更多位上工作）。

实施例：

big_set：100111001111100011000111110001100（将是数十亿比特的现实）

small_set：111111，所以ss_size是6（可以是比特不可预测的数目） 。

我需要big_set的6位长度的部分，例如：001100，000111等实验值：未必第N 6位，也可能是从3日至9位，例如。我不知道我怎么能得到它。

我不想得到一个big_set复制除了我将采取的6位，如在000000001111100000000000000000000，因为这也将非常昂贵的RAM非常复制。

的问题是：我怎样才能得到N位从任何地方内big_set，所以我可以做他们和small_set之间的位操作？作为N = ss_size。

Answer 1

我不确定下面给出的例子会给出你的问题的答案，我也不确定已实现的XOR是否能正常工作。

但我试图说明，如果任务是保存内存，算法的实现是多么令人困惑。

这是small_set我在big_set 40位和第6位的情况下，例如：

#include <stdlib.h> 
#include <stdio.h> 
#include <stdint.h> 

void setBitsInMemory(uint8_t * memPtr, size_t from, size_t to) 
// sets bits in the memory allocated from memPtr (pointer to the first byte) 
// where from and to are numbers of bits to be set 
{ 
    for (size_t i = from; i <= to; i++) 
    { 
     size_t block = i/8; 
     size_t offset = i % 8; 
     *(memPtr + block) |= 0x1 << offset; 
    } 
} 

uint8_t * allocAndBuildSmallSet(size_t bitNum) 
// Allocate memory to store bitNum bits and set them to 1 
{ 
    uint8_t * ptr = NULL; 
    size_t byteNum = 1 + bitNum/8; // determine number of bytes for 
    ptr = (uint8_t*) malloc(byteNum); 
    if (ptr != NULL) 
    { 
     for (size_t i = 0; i < byteNum; i++) ptr[i] = 0; 
     setBitsInMemory(ptr, 0, bitNum - 1); 
    } 
    return ptr; 
} 

void printBits(uint8_t * memPtr, size_t from, size_t to) 
{ 
    for (size_t i = from; i <= to; i++) 
    { 
     size_t block = i/8; 
     size_t offset = i % 8; 
     if (*(memPtr + block) & (0x1 << offset)) 
      printf("1"); 
     else 
      printf("0"); 
    } 
} 

void applyXOR(uint8_t * mainMem, size_t start, size_t cnt, uint8_t * pattern, size_t ptrnSize) 
// Applys bitwise XOR between cnt bits of mainMem and pattern 
// starting from start bit in mainMem and 0 bit in pattern 
// if pattern is smaller than cnt, it will be applyed cyclically 
{ 
    size_t ptrnBlk = 0; 
    size_t ptrnOff = 0; 
    for (size_t i = start; i < start + cnt; i++) 
    { 
     size_t block = i/8; 
     size_t offset = i % 8; 
     *(mainMem + block) ^= ((*(pattern + ptrnBlk) & (0x1 << ptrnOff)) ? 1 : 0) << offset; 
     ptrnOff++; 
     if ((ptrnBlk * 8 + ptrnOff) >= ptrnSize) 
     { 
      ptrnBlk = 0; 
      ptrnOff = 0; 
     } 
     if (ptrnOff % 8 == 0) 
     { 
      ptrnBlk++; 
      ptrnOff = 0; 
     } 
    } 
} 

int main(void) 
{ 
    uint8_t * big_set; 
    size_t ss_size; 
    uint8_t * small_set; 
    big_set = (uint8_t*)malloc(5); // 5 bytes (40 bit) without initialization 
    ss_size = 6; 
    small_set = allocAndBuildSmallSet(ss_size); 
    printf("Initial big_set:\n"); 
    printBits(big_set, 0, 39); 
    // some operation for ss_size bits starting from 12th 
    applyXOR(big_set, 12, ss_size, small_set, ss_size); 
    // output for visual analysis 
    printf("\nbig_set after XOR with small_set:\n"); 
    printBits(big_set, 0, 39); 
    printf("\n"); 
    // free memory 
    free(big_set); 
    free(small_set); 
} 

在我的电脑我可以看到以下内容：