-
Notifications
You must be signed in to change notification settings - Fork 30k
Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
deps: update zlib to 1.3.0.1-motley-c2469fd
PR-URL: #53464 Reviewed-By: Chemi Atlow <[email protected]> Reviewed-By: Marco Ippolito <[email protected]> Reviewed-By: Rafael Gonzaga <[email protected]> Reviewed-By: James M Snell <[email protected]>
- Loading branch information
1 parent
e7db639
commit d0c23f3
Showing
21 changed files
with
1,259 additions
and
1 deletion.
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,312 @@ | ||
| /* | ||
| * Copyright (C) 2024 Intel Corporation. All rights reserved. | ||
| * Authors: | ||
| * Gustavo A Espinoza <[email protected]> | ||
| * <[email protected]> | ||
| * | ||
| * For conditions of distribution and use, see copyright notice in zlib.h | ||
| */ | ||
| #include "deflate_qat.h" | ||
| #include "deflate.h" | ||
|
|
||
| #include "session.hpp" | ||
| #include "qat_instance.hpp" | ||
| #include "qat_buffer_list.hpp" | ||
| #include "qat.hpp" | ||
|
|
||
| #include <memory> | ||
|
|
||
| /* | ||
| * TODO(gustavoa): Make the input size adjustable from the memlevel | ||
| * attribute on deflateInit. | ||
| */ | ||
| static constexpr size_t kInputSize = 1024 * 1024; | ||
|
|
||
| /* QAT Instances obtained available from the library. */ | ||
| static std::vector<std::shared_ptr<qat::Instance>> qat_instances; | ||
|
|
||
| /* | ||
| * TODO(gustavoa): Verify if the ordering of the struct fields won't create | ||
| * unnecessary holes in the structure that requires extraneous padding. | ||
| */ | ||
| struct qat_deflate { | ||
| std::unique_ptr<qat::DeflateSession> qat_session; | ||
|
|
||
| /* QAT requires contiguous physical pages. Cannot be allocated using | ||
| * malloc/new. | ||
| */ | ||
| uint8_t *input_buffer; | ||
| uint8_t *output_buffer; | ||
|
|
||
| /* Pointer to the next byte in the output buffer. */ | ||
| uint8_t *pending_out; | ||
|
|
||
| unsigned input_buffer_size; | ||
| unsigned output_buffer_size; | ||
|
|
||
| unsigned pending_in_count; | ||
| unsigned pending_out_count; | ||
| }; | ||
|
|
||
| static std::unique_ptr<qat::DeflateSession> qat_create_session(int level, int wrap) | ||
| { | ||
| CpaDcChecksum checksum = CPA_DC_NONE; | ||
|
|
||
| switch(wrap) { | ||
| case 1: | ||
| checksum = CPA_DC_ADLER32; | ||
| break; | ||
| case 2: | ||
| checksum = CPA_DC_CRC32; | ||
| break; | ||
| } | ||
|
|
||
| return std::make_unique<qat::DeflateSession>( | ||
| qat_instances[0], | ||
| (CpaDcCompLvl)level, | ||
| checksum, | ||
| 0 | ||
| ); | ||
| } | ||
|
|
||
|
|
||
| int qat_deflate_init() | ||
| { | ||
| return (qat::Initialize()) ? Z_ERRNO : Z_OK; | ||
| } | ||
|
|
||
| struct qat_deflate* qat_deflate_state_init(int level, int wrap) | ||
| { | ||
| if (qat_instances.empty()) { | ||
| qat_instances = qat::Instance::Create(); | ||
| } | ||
| if (qat_instances.empty()) { | ||
| return nullptr; | ||
| } | ||
|
|
||
| struct qat_deflate *qat_deflate = new struct qat_deflate; | ||
| if (!qat_deflate) { | ||
| return nullptr; | ||
| } | ||
|
|
||
| /* TODO(gustavoa): Find a way to utilize all the available instances for the same | ||
| * process. | ||
| */ | ||
| qat_instances[0]->Start(); | ||
|
|
||
| qat_deflate->qat_session = qat_create_session(level, wrap); | ||
|
|
||
| qat_deflate->input_buffer_size = kInputSize; | ||
| qat_deflate->input_buffer = qat::AllocBlockArray<uint8_t>(kInputSize, 0); | ||
| qat_deflate->output_buffer_size = | ||
| qat_deflate->qat_session->GetDeflateBound(qat_deflate->input_buffer_size); | ||
| qat_deflate->pending_out = qat_deflate->output_buffer = | ||
| qat::AllocBlockArray<uint8_t>(qat_deflate->output_buffer_size, 0); | ||
|
|
||
| qat_deflate->pending_in_count = qat_deflate->pending_out_count = 0; | ||
|
|
||
| if (!qat_deflate->input_buffer || !qat_deflate->output_buffer) { | ||
| return nullptr; | ||
| } | ||
|
|
||
| return qat_deflate; | ||
| } | ||
|
|
||
| static unsigned qat_read_buf(z_streamp strm, struct qat_deflate* qat, unsigned size) | ||
| { | ||
| unsigned len = strm->avail_in; | ||
|
|
||
| if (len > size) { | ||
| len = size; | ||
| } | ||
| if (len == 0) return 0; | ||
|
|
||
| strm->avail_in -= len; | ||
| strm->total_in += len; | ||
|
|
||
| zmemcpy( | ||
| qat->input_buffer + qat->pending_in_count, | ||
| strm->next_in, | ||
| len | ||
| ); | ||
|
|
||
| strm->next_in += len; | ||
| qat->pending_in_count += len; | ||
|
|
||
| return len; | ||
| } | ||
|
|
||
| void qat_flush_pending(deflate_state* s) | ||
| { | ||
| unsigned len; | ||
| z_streamp strm = s->strm; | ||
| struct qat_deflate* qat = s->qat_s; | ||
|
|
||
| len = qat->pending_out_count; | ||
| if (len > strm->avail_out) len = strm->avail_out; | ||
| if (len == 0) return; | ||
|
|
||
| zmemcpy(strm->next_out, qat->pending_out, len); | ||
|
|
||
| qat->pending_out += len; | ||
| qat->pending_out_count -= len; | ||
| strm->next_out += len; | ||
| strm->avail_out -= len; | ||
| strm->total_out += len; | ||
| if (qat->pending_out_count == 0) { | ||
| qat->pending_out = qat->output_buffer; | ||
| } | ||
| } | ||
|
|
||
| static int qat_compress_pending(deflate_state*s, int flush) | ||
| { | ||
| struct qat_deflate* qat = s->qat_s; | ||
| uint32_t metadata_size; | ||
|
|
||
| /* TODO(gustavoa): find a way to make qatzpp setup this number internally. */ | ||
| cpaDcBufferListGetMetaSize(qat->qat_session->getInstance()->GetHandle(), 1, &metadata_size); | ||
|
|
||
| auto job = qat->qat_session->Deflate( | ||
| std::make_unique<qat::IOBuffers>( | ||
| std::make_unique<qat::BufferListUser>( | ||
| qat->input_buffer, | ||
| qat->pending_in_count, | ||
| metadata_size | ||
| ), | ||
| std::make_unique<qat::BufferListUser>( | ||
| qat->output_buffer, | ||
| qat->output_buffer_size, | ||
| metadata_size | ||
| ) | ||
| ), (flush == Z_FINISH && s->strm->avail_in == 0) | ||
| ); | ||
|
|
||
| job->WaitCompletion(); | ||
|
|
||
| /* | ||
| * TODO(gustavoa): make QAT perform the checksum combine. | ||
| */ | ||
| if (s->wrap == 2) { | ||
| s->strm->adler = crc32_combine( | ||
| s->strm->adler, | ||
| job->GetResults()->checksum, | ||
| job->GetResults()->consumed | ||
| ); | ||
| } else if (s->wrap == 1) { | ||
| s->strm->adler = adler32( | ||
| s->strm->adler, | ||
| qat->input_buffer, | ||
| job->GetResults()->consumed | ||
| ); | ||
| } | ||
|
|
||
| qat->pending_out_count = job->GetResults()->produced; | ||
| qat->pending_in_count -= job->GetResults()->consumed; | ||
|
|
||
| if(qat->pending_in_count != 0) { | ||
| /* Copy any remaining bytes to the beginning of the buffer. */ | ||
| zmemcpy( | ||
| qat->input_buffer, | ||
| qat->input_buffer + job->GetResults()->consumed, | ||
| qat->pending_in_count | ||
| ); | ||
| } | ||
|
|
||
| return 0; | ||
| } | ||
|
|
||
| qat_block_state qat_deflate_step(deflate_state* s, int flush) | ||
| { | ||
| z_streamp strm = s->strm; | ||
| struct qat_deflate* qat_state = s->qat_s; | ||
|
|
||
| for (;;) { | ||
| if (qat_state->pending_in_count < qat_state->input_buffer_size) { | ||
| qat_read_buf( | ||
| strm, | ||
| qat_state, | ||
| qat_state->input_buffer_size - qat_state->pending_in_count | ||
| ); | ||
| if (qat_state->pending_in_count < qat_state->input_buffer_size && flush == Z_NO_FLUSH) { | ||
| return qat_block_need_more; | ||
| } else { | ||
| qat_compress_pending(s, flush); | ||
| } | ||
| if (strm->avail_in == 0) { | ||
| break; | ||
| } | ||
| } else { | ||
| qat_compress_pending(s, flush); | ||
| } | ||
|
|
||
| qat_flush_pending(s); | ||
| if (strm->avail_out == 0) { | ||
| return (flush == Z_FINISH) ? qat_block_finish_started : qat_block_need_more; | ||
| } | ||
| } | ||
|
|
||
| if (flush == Z_FINISH) { | ||
| qat_flush_pending(s); | ||
| if (strm->avail_out == 0) { | ||
| return qat_block_finish_started; | ||
| } else { | ||
| return qat_block_finish_done; | ||
| } | ||
| } | ||
|
|
||
| qat_flush_pending(s); | ||
| if (strm->avail_out == 0) { | ||
| return qat_block_done; | ||
| } | ||
|
|
||
| return qat_block_need_more; | ||
| } | ||
|
|
||
| int qat_deflate_state_free(deflate_state* s) | ||
| { | ||
| struct qat_deflate* qat_state = s->qat_s; | ||
| if (qat_state->input_buffer) { | ||
| qat::Free(qat_state->input_buffer); | ||
| } | ||
| if (qat_state->output_buffer) { | ||
| qat::Free(qat_state->output_buffer); | ||
| } | ||
|
|
||
| qat_state->qat_session.reset(); | ||
| delete qat_state; | ||
| s->qat_s = nullptr; | ||
|
|
||
| return Z_OK; | ||
| } | ||
|
|
||
| struct qat_deflate *qat_deflate_copy(deflate_state *ss) | ||
| { | ||
| struct qat_deflate *sqat = ss->qat_s; | ||
| struct qat_deflate *dqat = nullptr; | ||
|
|
||
| if (!sqat) { | ||
| return nullptr; | ||
| } | ||
|
|
||
| dqat = new struct qat_deflate; | ||
|
|
||
| dqat->qat_session = qat_create_session(ss->level, ss->wrap); | ||
|
|
||
| dqat->input_buffer_size = sqat->input_buffer_size; | ||
| dqat->input_buffer = qat::AllocBlockArray<uint8_t>(dqat->input_buffer_size, 0); | ||
|
|
||
| dqat->output_buffer_size = sqat->output_buffer_size; | ||
| dqat->output_buffer = qat::AllocBlockArray<uint8_t>(dqat->output_buffer_size, 0); | ||
|
|
||
| dqat->pending_in_count = sqat->pending_in_count; | ||
| dqat->pending_out_count = sqat->pending_out_count; | ||
|
|
||
| dqat->pending_out = | ||
| dqat->output_buffer + (sqat->pending_out - sqat->output_buffer); | ||
|
|
||
| zmemcpy(dqat->input_buffer, sqat->input_buffer, dqat->input_buffer_size); | ||
| zmemcpy(dqat->output_buffer, sqat->output_buffer, dqat->output_buffer_size); | ||
|
|
||
| return dqat; | ||
| } | ||
|
|
Oops, something went wrong.