Twerk from Home fucked around with this message at 04:30 on Jul 17, 2022

Twerk from Home fucked around with this message at 19:21 on Jul 18, 2022

Twerk from Home fucked around with this message at 21:54 on Jul 19, 2022

Twerk from Home fucked around with this message at 04:33 on Aug 30, 2022

#include <__algorithm/copy.h>            // for copy
#include <__algorithm/find.h>            // for find
#include <__algorithm/max.h>             // for max
#include <__algorithm/min.h>             // for min
#include <__functional/operations.h>     // for plus
#include <__memory/unique_ptr.h>         // for unique_ptr
#include <__utility/forward.h>           // for forward
#include <__utility/integer_sequence.h>  // for index_sequence, make_index_s...
#include <__string>                      // for char_traits<>::pos_type
#include <__tuple>                       // for tuple_size

Twerk from Home fucked around with this message at 15:58 on Aug 30, 2022

    if  (phenotypes_.capacity() < phenotypes_.size() + 3) {
        phenotypes_.resize(phenotypes_.size() + 3);
    }

    for (; i + 15 < pairs.first.size(); i+= 16) {
        auto left_addresses = _mm512_loadu_si512(&pairs.first[i]);
        auto right_addresses = _mm512_loadu_si512(&pairs.second[i]);

        auto lefts = _mm512_i32gather_epi32(left_addresses, phenotypes_.data(), 1);
        auto rights = _mm512_i32gather_epi32(right_addresses, phenotypes_.data(), 1);
        
        auto left_packed = _mm512_cvtepi32_epi8(lefts);
        auto right_packed = _mm512_cvtepi32_epi8(rights);

        auto cscs_batch = _mm_and_si128(left_packed, right_packed);
        auto cscn_batch = _mm_xor_si128(left_packed, right_packed);

        cscs += popcnt128(cscs_batch);
        cscn += popcnt128(cscn_batch);
    }

        for (size_t i = 0; i + 1 < pairs.size(); i += 2) {

            const auto [p1_a, p1_b] = pairs[i];
            const auto x1 = phenotypes_[p1_a];
            const auto y1 = phenotypes_[p1_b];

            cscs += x1 & y1;
            cscn += x1 ^ y1;

            const auto [p2_a, p2_b] = pairs[i + 1];
            auto x2 = phenotypes_[p2_a];
            auto y2 = phenotypes_[p2_b];

            cscs2 += x2 & y2;
            cscn2 += x2 ^ y2;
        }

Twerk from Home fucked around with this message at 18:25 on Nov 8, 2022

std::unique_ptr<Base> buildABase() {
    return std::make_unique<Derived>(Derived());
}

struct Consumer {
    Consumer(std::unique_ptr<Base> &&inputBase) : myMember{std::move(inputBase)} {};
    std::unique_ptr<Base> myMember;
};

Twerk from Home fucked around with this message at 05:11 on Nov 16, 2022

    Consumer(std::unique_ptr<Base> &&inputBase) : myMember{std::move(inputBase)} {};
    Consumer(Base*& po_base) : myMember(po_base) {po_base = nullptr;}

Twerk from Home fucked around with this message at 05:32 on Nov 16, 2022

Twerk from Home fucked around with this message at 19:53 on Oct 27, 2023

Twerk from Home fucked around with this message at 16:16 on Dec 11, 2023

Twerk from Home fucked around with this message at 17:00 on Dec 11, 2023

__attribute__ ((noinline))
size_t count_returns(char * data, size_t length) {
    size_t answer = 0;
    for(size_t i = 0; i < length; i++) {
      if (data[i] == '\n') answer++;
    }
    return answer;
}

void count_lines_benchmark(size_t size) {
    printf(" %s\n", __PRETTY_FUNCTION__);
    bool verbose = true;
    printf("generating and parsing input having %zu bytes.\n", size);
    int repeat = 10;
    std::vector<char> blob(size + 1, 'a');
    blob [size] = '\0';
    // average line length should be 80
    for(size_t br = 0; br < size / 80; br++) {
      blob[rand() % size] = '\n';
    }
    size_t c = 0;
    BEST_TIME_NS((c = count_returns(blob.data(), blob.size())), , repeat, size, verbose);
    printf("bogus = %zu \n", c);
}

int main(int argc, char** argv) {
  count_lines_benchmark(10000000);
  get_line_benchmark(10000000);
  get_line_predictable_benchmark(10000000);
  return EXIT_SUCCESS;
}

 void count_lines_benchmark(size_t)
generating and parsing input having 10000000 bytes.
(c = count_returns(blob.data(), blob.size()))               :  41 ns total,  0.00 ns per byte  or 227151.85 GB/s 
bogus = 124230 
 void get_line_benchmark(size_t)
generating and parsing input having 10000000 bytes.
sum_line_lengths(ss)                                        :  28198375 ns total,  2.82 ns per byte  or 0.33 GB/s 
 void get_line_predictable_benchmark(size_t)
generating and parsing input having 10000000 bytes.
sum_line_lengths(ss)                                        :  28372542 ns total,  2.84 ns per byte  or 0.33 GB/s 

 void count_lines_benchmark(size_t)
generating and parsing input having 10000000 bytes.
(c = count_returns(blob.data(), blob.size()))               :  4142333 ns total,  0.41 ns per byte  or 2.25 GB/s 
bogus = 124230 
 void get_line_benchmark(size_t)
generating and parsing input having 10000000 bytes.
sum_line_lengths(ss)                                        :  28193042 ns total,  2.82 ns per byte  or 0.33 GB/s 
 void get_line_predictable_benchmark(size_t)
generating and parsing input having 10000000 bytes.
sum_line_lengths(ss)                                        :  28329542 ns total,  2.83 ns per byte  or 0.33 GB/s 

 void count_lines_benchmark(size_t)
generating and parsing input having 10000000 bytes.
(c = count_returns(blob.data(), blob.size()))               :  3473586 ns total,  0.35 ns per byte  or 2.68 GB/s 
bogus = 124250 
 void get_line_benchmark(size_t)
generating and parsing input having 10000000 bytes.
sum_line_lengths(ss)                                        :  6283024 ns total,  0.63 ns per byte  or 1.48 GB/s 
 void get_line_predictable_benchmark(size_t)
generating and parsing input having 10000000 bytes.
sum_line_lengths(ss)                                        :  3708638 ns total,  0.37 ns per byte  or 2.51 GB/s 

Twerk from Home fucked around with this message at 21:07 on Dec 26, 2023