Array<uint8_t> compress(RawArray<const uint8_t> data, int level, event_t event) {
thread_time_t time(compress_kind,event);
if (level<20) { // zlib
size_t dest_size = compressBound(data.size());
Array<uint8_t> compressed(CHECK_CAST_INT(dest_size),uninit);
int z = compress2(compressed.data(),&dest_size,(uint8_t*)data.data(),data.size(),level);
if (z!=Z_OK)
THROW(IOError,"zlib failure in compress_and_write: %s",zlib_error(z));
return compressed.slice_own(0,CHECK_CAST_INT(dest_size));
} else { // lzma
size_t dest_size = lzma_stream_buffer_bound(data.size());
Array<uint8_t> compressed(CHECK_CAST_INT(dest_size),uninit);
size_t pos = 0;
lzma_ret r = lzma_easy_buffer_encode(level-20,LZMA_CHECK_CRC64,0,data.data(),data.size(),compressed.data(),&pos,dest_size);
if (r!=LZMA_OK)
THROW(RuntimeError,"lzma compression error: %s (%d)",lzma_error(r),r);
return compressed.slice_own(0,CHECK_CAST_INT(pos));
}
}
Array<uint8_t> decompress(RawArray<const uint8_t> compressed, const size_t uncompressed_size, event_t event) {
GEODE_ASSERT(uncompressed_size<(uint64_t)1<<31);
thread_time_t time(decompress_kind,event);
size_t dest_size = uncompressed_size;
Array<uint8_t> uncompressed = aligned_buffer<uint8_t>(CHECK_CAST_INT(dest_size));
if (!is_lzma(compressed)) { // zlib
int z = uncompress((uint8_t*)uncompressed.data(),&dest_size,compressed.data(),compressed.size());
if (z!=Z_OK)
THROW(IOError,"zlib failure in read_and_uncompress: %s",zlib_error(z));
} else { // lzma
const uint32_t flags = LZMA_TELL_NO_CHECK | LZMA_TELL_UNSUPPORTED_CHECK;
uint64_t memlimit = UINT64_MAX;
size_t in_pos = 0, out_pos = 0;
lzma_ret r = lzma_stream_buffer_decode(&memlimit,flags,0,compressed.data(),&in_pos,compressed.size(),uncompressed.data(),&out_pos,dest_size);
if (r!=LZMA_OK)
THROW(IOError,"lzma failure in read_and_uncompress: %s (%d)",lzma_error(r),r);
}
if (dest_size != uncompressed_size)
THROW(IOError,"read_and_compress: expected uncompressed size %zu, got %zu",uncompressed_size,dest_size);
return uncompressed;
}
Vector<uint64_t,3> count_block_wins(const section_t section, const Vector<uint8_t,4> block, RawArray<const Vector<super_t,2>> flat_data) {
// Prepare
const auto base = block_size*Vector<int,4>(block);
const auto shape = block_shape(section.shape(),block);
const auto rmin0 = safe_rmin_slice(section.counts[0],base[0]+range(shape[0])),
rmin1 = safe_rmin_slice(section.counts[1],base[1]+range(shape[1])),
rmin2 = safe_rmin_slice(section.counts[2],base[2]+range(shape[2])),
rmin3 = safe_rmin_slice(section.counts[3],base[3]+range(shape[3]));
GEODE_ASSERT(shape.product()==flat_data.size());
const RawArray<const Vector<super_t,2>,4> block_data(shape,flat_data.data());
// Count
Vector<uint64_t,3> counts;
for (int i0=0;i0<shape[0];i0++)
for (int i1=0;i1<shape[1];i1++)
for (int i2=0;i2<shape[2];i2++)
for (int i3=0;i3<shape[3];i3++)
counts += Vector<uint64_t,3>(popcounts_over_stabilizers(quadrants(rmin0[i0],rmin1[i1],rmin2[i2],rmin3[i3]),block_data(i0,i1,i2,i3)));
return counts;
}
static bool is_lzma(RawArray<const uint8_t> data) {
static const uint8_t magic[6] = {0xfd,'7','z','X','Z',0};
return data.size()>=6 && !memcmp(data.data(),magic,6);
}
compact_blob_t supertensor_index_t::block_location(RawArray<const uint8_t> blob) {
compact_blob_t b;
GEODE_ASSERT(blob.size()==sizeof(b),format("expected size %d, got size %d, data %s",sizeof(b),blob.size(),str(blob)));
memcpy(&b,blob.data(),sizeof(b));
return b;
}
static inline RawArray<mp_limb_t> sqrt_helper(RawArray<mp_limb_t> result, RawArray<const mp_limb_t> x) {
const auto s = result.slice(0,(1+x.size())/2);
mpn_sqrtrem(s.data(),0,x.data(),x.size());
return trim(s);
}
