(FUZZING) Получить указатель на диапазон данных массива Dynami c - PullRequest
Новая
       64

(FUZZING) Получить указатель на диапазон данных массива Dynami c

0 голосов
/ 18 июня 2020

РЕДАКТИРОВАТЬ: Уточнение:

Если у меня есть массив int* a = new int[10], я хочу получить указатель на a, но только значения от 0 до 5, без необходимости выделять другой массив для этих значений.

Исходное сообщение:

Я создал небольшой класс для размытия моих функций, но дело в том, что он очень медленный. Чтобы выполнить 1000 раз мою функцию, требуется примерно 10-20 секунд. указатель на этот диапазон, который будет использоваться в моей функции вместо выделения памяти и ее удаления каждый раз.

Ниже мой код.

Сначала я пытаюсь выделить 1 миллион байтов, затем я хочу вернуть диапазон от 0 до любого размера, созданного моим классом. В настоящее время я выделяю память еще раз для ее возврата, но это неэффективно.

Я использую Xorshift для генерации случайных чисел, что должно быть намного быстрее, чем rand (), поэтому я думаю, что помимо выделения памяти это довольно хорошо, но любой предложения очень приветствуются!

Примечание: если вы не понимаете часть моего кода, спросите меня (он написан быстро, поэтому в некоторых частях он может быть неразборчивым);) 

class fuzz {
public:

    fuzz() {
        this->alloc_init_buff();
    }

    ~fuzz() {
        this->dealloc_init_buff();
    }

    int fill_buff(unsigned int size) {
        if (size > this->m_buffsize) { size = this->m_buffsize; }
        for (int i = 0; i < size; ++i) {
            this->m_buff[i] = this->rand_xor();
        }
        return size;
    }

    int fill_buff() {
        int size = this->rand_xor(1, this->m_buffsize);
        if (size > this->m_buffsize) { size = this->m_buffsize; }
        for (int i = 0; i < size; ++i) {
            this->m_buff[i] = this->rand_xor();
        }
        return size;
    }

    unsigned char*& get_buff(int size) {
        unsigned char* temp = new unsigned char[size];
        memcpy((void*)temp, (void*)this->m_buff, size);
        return temp;
    }

private:

    struct xr_xorshift_state {
        unsigned int a = 123456789, b = 362436069, c = 521288629, d = 88675123;
    };

    unsigned int xorshift(xr_xorshift_state* state) {
        unsigned int res = 0;
        res = state->a ^ (state->a << 11);
        state->a = state->b; state->b = state->c; state->c = state->d;
        state->d = state->d ^ (state->d >> 19) ^ (res ^ (res >> 8));
        res &= 0x7fffffff;
        return res;
    }

    unsigned int rand_xor() {
        return this->xorshift(&this->m_state);
    }

    unsigned int rand_xor(unsigned int min, unsigned int max) {
        return (min + (this->rand_xor() % (max - min)));
    }

    void alloc_init_buff() {
        this->m_buff = new unsigned char[this->m_buffsize];
    }

    void dealloc_init_buff() {
        delete[] this->m_buff;
    }

    xr_xorshift_state m_state = { 0 };
    unsigned char* m_buff = { 0 };
    unsigned int m_buffsize = { 1000000 };
};

int find_newline(const char* text, int size) {
    int pos = 0;
    while (*text != '\n') {
        if (pos == size) { return 0; }
        ++text; ++pos;
    }
    return pos;
}

int main() {
    fuzz fz = {};
    unsigned char* randdata = nullptr;
    int lap = 0;
    int th = 0;
    for (;;) {
        if (lap == 1000) {
            lap = 0;
            ++th;
            printf("%d thousand laps done!\n", th);
        }
        try {
            int size = fz.fill_buff();
            randdata = fz.get_buff(size);
            const char* d = (const char*)randdata;
            find_newline(d, size);
            delete[] randdata;
            ++lap;
        }
        catch (...) {
            printf("error!\n");
            ++lap;
        }
    }
    getchar();
    return 0;
}
...