[PATCH 4/5] selftests/powerpc: Add NX-GZIP engine decompress testcase
Daniel Axtens
dja at axtens.net
Wed Mar 18 15:31:05 AEDT 2020
Raphael Moreira Zinsly <rzinsly at linux.ibm.com> writes:
> Include a decompression testcase for the powerpc NX-GZIP
> engine.
>
> Signed-off-by: Bulent Abali <abali at us.ibm.com>
> Signed-off-by: Raphael Moreira Zinsly <rzinsly at linux.ibm.com>
> ---
> .../selftests/powerpc/nx-gzip/Makefile | 7 +-
> .../selftests/powerpc/nx-gzip/gunz_test.c | 1058 +++++++++++++++++
> 2 files changed, 1062 insertions(+), 3 deletions(-)
> create mode 100644 tools/testing/selftests/powerpc/nx-gzip/gunz_test.c
>
> diff --git a/tools/testing/selftests/powerpc/nx-gzip/Makefile b/tools/testing/selftests/powerpc/nx-gzip/Makefile
> index ab903f63bbbd..82abc19a49a0 100644
> --- a/tools/testing/selftests/powerpc/nx-gzip/Makefile
> +++ b/tools/testing/selftests/powerpc/nx-gzip/Makefile
> @@ -1,9 +1,9 @@
> CC = gcc
> CFLAGS = -O3
> INC = ./inc
> -SRC = gzfht_test.c
> +SRC = gzfht_test.c gunz_test.c
> OBJ = $(SRC:.c=.o)
> -TESTS = gzfht_test
> +TESTS = gzfht_test gunz_test
> EXTRA_SOURCES = gzip_vas.c
>
> all: $(TESTS)
> @@ -16,6 +16,7 @@ $(TESTS): $(OBJ)
>
> run_tests: $(TESTS)
> ./gzfht_test gzip_vas.c
> + ./gunz_test gzip_vas.c.nx.gz
>
> clean:
> - rm -f $(TESTS) *.o *~ *.gz
> + rm -f $(TESTS) *.o *~ *.gz *.gunzip
> diff --git a/tools/testing/selftests/powerpc/nx-gzip/gunz_test.c b/tools/testing/selftests/powerpc/nx-gzip/gunz_test.c
> new file mode 100644
> index 000000000000..653de92698cc
> --- /dev/null
> +++ b/tools/testing/selftests/powerpc/nx-gzip/gunz_test.c
> @@ -0,0 +1,1058 @@
> +/* SPDX-License-Identifier: GPL-2.0-or-later
> + *
> + * P9 gunzip sample code for demonstrating the P9 NX hardware
> + * interface. Not intended for productive uses or for performance or
> + * compression ratio measurements. Note also that /dev/crypto/gzip,
> + * VAS and skiboot support are required
> + *
> + * Copyright 2020 IBM Corp.
> + *
> + * Author: Bulent Abali <abali at us.ibm.com>
> + *
> + * https://github.com/libnxz/power-gzip for zlib api and other utils
> + * Definitions of acronyms used here. See
> + * P9 NX Gzip Accelerator User's Manual for details
> + *
> + * adler/crc: 32 bit checksums appended to stream tail
> + * ce: completion extension
> + * cpb: coprocessor parameter block (metadata)
> + * crb: coprocessor request block (command)
> + * csb: coprocessor status block (status)
> + * dht: dynamic huffman table
> + * dde: data descriptor element (address, length)
> + * ddl: list of ddes
> + * dh/fh: dynamic and fixed huffman types
> + * fc: coprocessor function code
> + * histlen: history/dictionary length
> + * history: sliding window of up to 32KB of data
> + * lzcount: Deflate LZ symbol counts
> + * rembytecnt: remaining byte count
> + * sfbt: source final block type; last block's type during decomp
> + * spbc: source processed byte count
> + * subc: source unprocessed bit count
> + * tebc: target ending bit count; valid bits in the last byte
> + * tpbc: target processed byte count
> + * vas: virtual accelerator switch; the user mode interface
> + */
> +
> +#include <stdio.h>
> +#include <stdlib.h>
> +#include <string.h>
> +#include <unistd.h>
> +#include <stdint.h>
> +#include <sys/types.h>
> +#include <sys/stat.h>
> +#include <sys/time.h>
> +#include <sys/fcntl.h>
> +#include <sys/mman.h>
> +#include <endian.h>
> +#include <bits/endian.h>
> +#include <sys/ioctl.h>
> +#include <assert.h>
> +#include <errno.h>
> +#include <signal.h>
> +#include "nxu.h"
> +#include "nx.h"
> +
> +int nx_dbg = 0;
> +FILE *nx_gzip_log = NULL;
> +
> +#define NX_MIN(X, Y) (((X) < (Y))?(X):(Y))
> +#define NX_MAX(X, Y) (((X) > (Y))?(X):(Y))
> +
> +#define mb() asm volatile("sync" ::: "memory")
> +#define rmb() asm volatile("lwsync" ::: "memory")
> +#define wmb() rmb()
> +
> +const int fifo_in_len = 1<<24;
> +const int fifo_out_len = 1<<24;
> +const int page_sz = 1<<16;
> +const int line_sz = 1<<7;
> +const int window_max = 1<<15;
> +const int retry_max = 50;
> +
> +extern void *nx_fault_storage_address;
> +extern void *nx_function_begin(int function, int pri);
> +extern int nx_function_end(void *handle);
> +
> +/*
> + * Fault in pages prior to NX job submission. wr=1 may be required to
> + * touch writeable pages. System zero pages do not fault-in the page as
> + * intended. Typically set wr=1 for NX target pages and set wr=0 for
> + * NX source pages.
> + */
> +static int nx_touch_pages(void *buf, long buf_len, long page_len, int wr)
> +{
> + char *begin = buf;
> + char *end = (char *) buf + buf_len - 1;
> + volatile char t;
> +
> + assert(buf_len >= 0 && !!buf);
> +
> + NXPRT(fprintf(stderr, "touch %p %p len 0x%lx wr=%d\n", buf,
> + buf + buf_len, buf_len, wr));
> +
> + if (buf_len <= 0 || buf == NULL)
> + return -1;
> +
> + do {
> + t = *begin;
> + if (wr)
> + *begin = t;
> + begin = begin + page_len;
> + } while (begin < end);
> +
> + /* When buf_sz is small or buf tail is in another page. */
> + t = *end;
> + if (wr)
> + *end = t;
> +
> + return 0;
> +}
> +
> +void sigsegv_handler(int sig, siginfo_t *info, void *ctx)
> +{
> + fprintf(stderr, "%d: Got signal %d si_code %d, si_addr %p\n", getpid(),
> + sig, info->si_code, info->si_addr);
> +
> + nx_fault_storage_address = info->si_addr;
> +}
> +
> +/*
> + * Adds an (address, len) pair to the list of ddes (ddl) and updates
> + * the base dde. ddl[0] is the only dde in a direct dde which
> + * contains a single (addr,len) pair. For more pairs, ddl[0] becomes
> + * the indirect (base) dde that points to a list of direct ddes.
> + * See Section 6.4 of the NX-gzip user manual for DDE description.
> + * Addr=NULL, len=0 clears the ddl[0]. Returns the total number of
> + * bytes in ddl. Caller is responsible for allocting the array of
> + * nx_dde_t *ddl. If N addresses are required in the scatter-gather
> + * list, the ddl array must have N+1 entries minimum.
> + */
> +static inline uint32_t nx_append_dde(nx_dde_t *ddl, void *addr, uint32_t len)
> +{
> + uint32_t ddecnt;
> + uint32_t bytes;
> +
> + if (addr == NULL && len == 0) {
> + clearp_dde(ddl);
> + return 0;
> + }
> +
> + NXPRT(fprintf(stderr, "%d: nx_append_dde addr %p len %x\n", __LINE__,
> + addr, len));
> +
> + /* Number of ddes in the dde list ; == 0 when it is a direct dde */
> + ddecnt = getpnn(ddl, dde_count);
> + bytes = getp32(ddl, ddebc);
> +
> + if (ddecnt == 0 && bytes == 0) {
> + /* First dde is unused; make it a direct dde */
> + bytes = len;
> + putp32(ddl, ddebc, bytes);
> + putp64(ddl, ddead, (uint64_t) addr);
> + } else if (ddecnt == 0) {
> + /* Converting direct to indirect dde
> + * ddl[0] becomes head dde of ddl
> + * copy direct to indirect first.
> + */
> + ddl[1] = ddl[0];
> +
> + /* Add the new dde next */
> + clear_dde(ddl[2]);
> + put32(ddl[2], ddebc, len);
> + put64(ddl[2], ddead, (uint64_t) addr);
> +
> + /* Ddl head points to 2 direct ddes */
> + ddecnt = 2;
> + putpnn(ddl, dde_count, ddecnt);
> + bytes = bytes + len;
> + putp32(ddl, ddebc, bytes);
> + /* Pointer to the first direct dde */
> + putp64(ddl, ddead, (uint64_t) &ddl[1]);
> + } else {
> + /* Append a dde to an existing indirect ddl */
> + ++ddecnt;
> + clear_dde(ddl[ddecnt]);
> + put64(ddl[ddecnt], ddead, (uint64_t) addr);
> + put32(ddl[ddecnt], ddebc, len);
> +
> + putpnn(ddl, dde_count, ddecnt);
> + bytes = bytes + len;
> + putp32(ddl, ddebc, bytes); /* byte sum of all dde */
> + }
> + return bytes;
> +}
> +
> +/*
> + * Touch specified number of pages represented in number bytes
> + * beginning from the first buffer in a dde list.
> + * Do not touch the pages past buf_sz-th byte's page.
> + *
> + * Set buf_sz = 0 to touch all pages described by the ddep.
> + */
> +static int nx_touch_pages_dde(nx_dde_t *ddep, long buf_sz, long page_sz,
> + int wr)
> +{
> + uint32_t indirect_count;
> + uint32_t buf_len;
> + long total;
> + uint64_t buf_addr;
> + nx_dde_t *dde_list;
> + int i;
> +
> + assert(!!ddep);
> +
> + indirect_count = getpnn(ddep, dde_count);
> +
> + NXPRT(fprintf(stderr, "nx_touch_pages_dde dde_count %d request len \
> + 0x%lx\n", indirect_count, buf_sz));
You use \ to break a string into multiple lines throughout this test
case.
It leads to things like this being printed:
ERR_NX_DATA_LENGTH; not an error usually; stream may have trailing data
Notice the big chunk of whitespace in the middle.
Could you use this instead please:
+ NXPRT(fprintf(stderr, "nx_touch_pages_dde dde_count %d request len "
+ "0x%lx\n", indirect_count, buf_sz));
Regards,
Daniel
> +
> + if (indirect_count == 0) {
> + /* Direct dde */
> + buf_len = getp32(ddep, ddebc);
> + buf_addr = getp64(ddep, ddead);
> +
> + NXPRT(fprintf(stderr, "touch direct ddebc 0x%x ddead %p\n",
> + buf_len, (void *)buf_addr));
> +
> + if (buf_sz == 0)
> + nx_touch_pages((void *)buf_addr, buf_len, page_sz, wr);
> + else
> + nx_touch_pages((void *)buf_addr, NX_MIN(buf_len,
> + buf_sz), page_sz, wr);
> +
> + return ERR_NX_OK;
> + }
> +
> + /* Indirect dde */
> + if (indirect_count > MAX_DDE_COUNT)
> + return ERR_NX_EXCESSIVE_DDE;
> +
> + /* First address of the list */
> + dde_list = (nx_dde_t *) getp64(ddep, ddead);
> +
> + if (buf_sz == 0)
> + buf_sz = getp32(ddep, ddebc);
> +
> + total = 0;
> + for (i = 0; i < indirect_count; i++) {
> + buf_len = get32(dde_list[i], ddebc);
> + buf_addr = get64(dde_list[i], ddead);
> + total += buf_len;
> +
> + NXPRT(fprintf(stderr, "touch loop len 0x%x ddead %p total \
> + 0x%lx\n", buf_len, (void *)buf_addr, total));
> +
> + /* Touching fewer pages than encoded in the ddebc */
> + if (total > buf_sz) {
> + buf_len = NX_MIN(buf_len, total - buf_sz);
> + nx_touch_pages((void *)buf_addr, buf_len, page_sz, wr);
> + NXPRT(fprintf(stderr, "touch loop break len 0x%x \
> + ddead %p\n", buf_len, (void *)buf_addr));
> + break;
> + }
> + nx_touch_pages((void *)buf_addr, buf_len, page_sz, wr);
> + }
> + return ERR_NX_OK;
> +}
> +
> +/*
> + * Src and dst buffers are supplied in scatter gather lists.
> + * NX function code and other parameters supplied in cmdp.
> + */
> +static int nx_submit_job(nx_dde_t *src, nx_dde_t *dst, nx_gzip_crb_cpb_t *cmdp,
> + void *handle)
> +{
> + int cc;
> + uint64_t csbaddr;
> +
> + memset((void *)&cmdp->crb.csb, 0, sizeof(cmdp->crb.csb));
> +
> + cmdp->crb.source_dde = *src;
> + cmdp->crb.target_dde = *dst;
> +
> + /* Status, output byte count in tpbc */
> + csbaddr = ((uint64_t) &cmdp->crb.csb) & csb_address_mask;
> + put64(cmdp->crb, csb_address, csbaddr);
> +
> + /* NX reports input bytes in spbc; cleared */
> + cmdp->cpb.out_spbc_comp_wrap = 0;
> + cmdp->cpb.out_spbc_comp_with_count = 0;
> + cmdp->cpb.out_spbc_decomp = 0;
> +
> + /* Clear output */
> + put32(cmdp->cpb, out_crc, INIT_CRC);
> + put32(cmdp->cpb, out_adler, INIT_ADLER);
> +
> + cc = nxu_run_job(cmdp, handle);
> +
> + if (!cc)
> + cc = getnn(cmdp->crb.csb, csb_cc); /* CC Table 6-8 */
> +
> + return cc;
> +}
> +
> +/* fifo queue management */
> +#define fifo_used_bytes(used) (used)
> +#define fifo_free_bytes(used, len) ((len)-(used))
> +/* amount of free bytes in the first and last parts */
> +#define fifo_free_first_bytes(cur, used, len) ((((cur)+(used)) <= (len)) \
> + ? (len)-((cur)+(used)) : 0)
> +#define fifo_free_last_bytes(cur, used, len) ((((cur)+(used)) <= (len)) \
> + ? (cur) : (len)-(used))
> +/* amount of used bytes in the first and last parts */
> +#define fifo_used_first_bytes(cur, used, len) ((((cur)+(used)) <= (len)) \
> + ? (used) : (len)-(cur))
> +#define fifo_used_last_bytes(cur, used, len) ((((cur)+(used)) <= (len)) \
> + ? 0 : ((used)+(cur))-(len))
> +/* first and last free parts start here */
> +#define fifo_free_first_offset(cur, used) ((cur)+(used))
> +#define fifo_free_last_offset(cur, used, len) \
> + fifo_used_last_bytes(cur, used, len)
> +/* first and last used parts start here */
> +#define fifo_used_first_offset(cur) (cur)
> +#define fifo_used_last_offset(cur) (0)
> +
> +int decompress_file(int argc, char **argv, void *devhandle)
> +{
> + FILE *inpf;
> + FILE *outf;
> +
> + int c, expect, i, cc, rc = 0;
> + char gzfname[1024];
> +
> + /* Queuing, file ops, byte counting */
> + char *fifo_in, *fifo_out;
> + int used_in, cur_in, used_out, cur_out, read_sz, n;
> + int first_free, last_free, first_used, last_used;
> + int first_offset, last_offset;
> + int write_sz, free_space, source_sz;
> + int source_sz_estimate, target_sz_estimate;
> + uint64_t last_comp_ratio; /* 1000 max */
> + uint64_t total_out;
> + int is_final, is_eof;
> +
> + /* nx hardware */
> + int sfbt, subc, spbc, tpbc, nx_ce, fc, resuming = 0;
> + int history_len = 0;
> + nx_gzip_crb_cpb_t cmd, *cmdp;
> + nx_dde_t *ddl_in;
> + nx_dde_t dde_in[6] __attribute__((aligned (128)));
> + nx_dde_t *ddl_out;
> + nx_dde_t dde_out[6] __attribute__((aligned (128)));
> + int pgfault_retries;
> +
> + /* when using mmap'ed files */
> + off_t input_file_offset;
> +
> + if (argc > 2) {
> + fprintf(stderr, "usage: %s <fname> or stdin\n", argv[0]);
> + fprintf(stderr, " writes to stdout or <fname>.nx.gunzip\n");
> + return -1;
> + }
> +
> + if (argc == 1) {
> + inpf = stdin;
> + outf = stdout;
> + } else if (argc == 2) {
> + char w[1024];
> + char *wp;
> + inpf = fopen(argv[1], "r");
> + if (inpf == NULL) {
> + perror(argv[1]);
> + return -1;
> + }
> +
> + /* Make a new file name to write to. Ignoring '.gz' */
> + wp = (NULL != (wp = strrchr(argv[1], '/'))) ? ++wp : argv[1];
> + strcpy(w, wp);
> + strcat(w, ".nx.gunzip");
> +
> + outf = fopen(w, "w");
> + if (outf == NULL) {
> + perror(w);
> + return -1;
> + }
> + }
> +
> +#define GETINPC(X) fgetc(X)
> +
> + /* Decode the gzip header */
> + c = GETINPC(inpf); expect = 0x1f; /* ID1 */
> + if (c != expect)
> + goto err1;
> +
> + c = GETINPC(inpf); expect = 0x8b; /* ID2 */
> + if (c != expect)
> + goto err1;
> +
> + c = GETINPC(inpf); expect = 0x08; /* CM */
> + if (c != expect)
> + goto err1;
> +
> + int flg = GETINPC(inpf); /* FLG */
> + if (flg & 0b11100000 || flg & 0b100)
> + goto err2;
> +
> + fprintf(stderr, "gzHeader FLG %x\n", flg);
> +
> + /* Read 6 bytes; ignoring the MTIME, XFL, OS fields in this
> + * sample code.
> + */
> + for (i = 0; i < 6; i++) {
> + char tmp[10];
> + if (EOF == (tmp[i] = GETINPC(inpf)))
> + goto err3;
> + fprintf(stderr, "%02x ", tmp[i]);
> + if (i == 5)
> + fprintf(stderr, "\n");
> + }
> + fprintf(stderr, "gzHeader MTIME, XFL, OS ignored\n");
> +
> + /* FNAME */
> + if (flg & 0b1000) {
> + int k = 0;
> + do {
> + if (EOF == (c = GETINPC(inpf)))
> + goto err3;
> + gzfname[k++] = c;
> + } while (c);
> + fprintf(stderr, "gzHeader FNAME: %s\n", gzfname);
> + }
> +
> + /* FHCRC */
> + if (flg & 0b10) {
> + c = GETINPC(inpf); c = GETINPC(inpf);
> + fprintf(stderr, "gzHeader FHCRC: ignored\n");
> + }
> +
> + used_in = cur_in = used_out = cur_out = 0;
> + is_final = is_eof = 0;
> +
> + /* Allocate one page larger to prevent page faults due to NX
> + * overfetching.
> + * Either do this (char*)(uintptr_t)aligned_alloc or use
> + * -std=c11 flag to make the int-to-pointer warning go away.
> + */
> + assert((fifo_in = (char *)(uintptr_t)aligned_alloc(line_sz,
> + fifo_in_len + page_sz)) != NULL);
> + assert((fifo_out = (char *)(uintptr_t)aligned_alloc(line_sz,
> + fifo_out_len + page_sz + line_sz)) != NULL);
> + /* Leave unused space due to history rounding rules */
> + fifo_out = fifo_out + line_sz;
> + nx_touch_pages(fifo_out, fifo_out_len, page_sz, 1);
> +
> + ddl_in = &dde_in[0];
> + ddl_out = &dde_out[0];
> + cmdp = &cmd;
> + memset(&cmdp->crb, 0, sizeof(cmdp->crb));
> +
> +read_state:
> +
> + /* Read from .gz file */
> +
> + NXPRT(fprintf(stderr, "read_state:\n"));
> +
> + if (is_eof != 0)
> + goto write_state;
> +
> + /* We read in to fifo_in in two steps: first: read in to from
> + * cur_in to the end of the buffer. last: if free space wrapped
> + * around, read from fifo_in offset 0 to offset cur_in.
> + */
> +
> + /* Reset fifo head to reduce unnecessary wrap arounds */
> + cur_in = (used_in == 0) ? 0 : cur_in;
> +
> + /* Free space total is reduced by a gap */
> + free_space = NX_MAX(0, fifo_free_bytes(used_in, fifo_in_len)
> + - line_sz);
> +
> + /* Free space may wrap around as first and last */
> + first_free = fifo_free_first_bytes(cur_in, used_in, fifo_in_len);
> + last_free = fifo_free_last_bytes(cur_in, used_in, fifo_in_len);
> +
> + /* Start offsets of the free memory */
> + first_offset = fifo_free_first_offset(cur_in, used_in);
> + last_offset = fifo_free_last_offset(cur_in, used_in, fifo_in_len);
> +
> + /* Reduce read_sz because of the line_sz gap */
> + read_sz = NX_MIN(free_space, first_free);
> + n = 0;
> + if (read_sz > 0) {
> + /* Read in to offset cur_in + used_in */
> + n = fread(fifo_in + first_offset, 1, read_sz, inpf);
> + used_in = used_in + n;
> + free_space = free_space - n;
> + assert(n <= read_sz);
> + if (n != read_sz) {
> + /* Either EOF or error; exit the read loop */
> + is_eof = 1;
> + goto write_state;
> + }
> + }
> +
> + /* If free space wrapped around */
> + if (last_free > 0) {
> + /* Reduce read_sz because of the line_sz gap */
> + read_sz = NX_MIN(free_space, last_free);
> + n = 0;
> + if (read_sz > 0) {
> + n = fread(fifo_in + last_offset, 1, read_sz, inpf);
> + used_in = used_in + n; /* Increase used space */
> + free_space = free_space - n; /* Decrease free space */
> + assert(n <= read_sz);
> + if (n != read_sz) {
> + /* Either EOF or error; exit the read loop */
> + is_eof = 1;
> + goto write_state;
> + }
> + }
> + }
> +
> + /* At this point we have used_in bytes in fifo_in with the
> + * data head starting at cur_in and possibly wrapping around.
> + */
> +
> +write_state:
> +
> + /* Write decompressed data to output file */
> +
> + NXPRT(fprintf(stderr, "write_state:\n"));
> +
> + if (used_out == 0)
> + goto decomp_state;
> +
> + /* If fifo_out has data waiting, write it out to the file to
> + * make free target space for the accelerator used bytes in
> + * the first and last parts of fifo_out.
> + */
> +
> + first_used = fifo_used_first_bytes(cur_out, used_out, fifo_out_len);
> + last_used = fifo_used_last_bytes(cur_out, used_out, fifo_out_len);
> +
> + write_sz = first_used;
> +
> + n = 0;
> + if (write_sz > 0) {
> + n = fwrite(fifo_out + cur_out, 1, write_sz, outf);
> + used_out = used_out - n;
> + /* Move head of the fifo */
> + cur_out = (cur_out + n) % fifo_out_len;
> + assert(n <= write_sz);
> + if (n != write_sz) {
> + fprintf(stderr, "error: write\n");
> + rc = -1;
> + goto err5;
> + }
> + }
> +
> + if (last_used > 0) { /* If more data available in the last part */
> + write_sz = last_used; /* Keep it here for later */
> + n = 0;
> + if (write_sz > 0) {
> + n = fwrite(fifo_out, 1, write_sz, outf);
> + used_out = used_out - n;
> + cur_out = (cur_out + n) % fifo_out_len;
> + assert(n <= write_sz);
> + if (n != write_sz) {
> + fprintf(stderr, "error: write\n");
> + rc = -1;
> + goto err5;
> + }
> + }
> + }
> +
> +decomp_state:
> +
> + /* NX decompresses input data */
> +
> + NXPRT(fprintf(stderr, "decomp_state:\n"));
> +
> + if (is_final)
> + goto finish_state;
> +
> + /* Address/len lists */
> + clearp_dde(ddl_in);
> + clearp_dde(ddl_out);
> +
> + /* FC, CRC, HistLen, Table 6-6 */
> + if (resuming) {
> + /* Resuming a partially decompressed input.
> + * The key to resume is supplying the 32KB
> + * dictionary (history) to NX, which is basically
> + * the last 32KB of output produced.
> + */
> + fc = GZIP_FC_DECOMPRESS_RESUME;
> +
> + cmdp->cpb.in_crc = cmdp->cpb.out_crc;
> + cmdp->cpb.in_adler = cmdp->cpb.out_adler;
> +
> + /* Round up the history size to quadword. Section 2.10 */
> + history_len = (history_len + 15) / 16;
> + putnn(cmdp->cpb, in_histlen, history_len);
> + history_len = history_len * 16; /* bytes */
> +
> + if (history_len > 0) {
> + /* Chain in the history buffer to the DDE list */
> + if (cur_out >= history_len) {
> + nx_append_dde(ddl_in, fifo_out
> + + (cur_out - history_len),
> + history_len);
> + } else {
> + nx_append_dde(ddl_in, fifo_out
> + + ((fifo_out_len + cur_out)
> + - history_len),
> + history_len - cur_out);
> + /* Up to 32KB history wraps around fifo_out */
> + nx_append_dde(ddl_in, fifo_out, cur_out);
> + }
> +
> + }
> + } else {
> + /* First decompress job */
> + fc = GZIP_FC_DECOMPRESS;
> +
> + history_len = 0;
> + /* Writing 0 clears out subc as well */
> + cmdp->cpb.in_histlen = 0;
> + total_out = 0;
> +
> + put32(cmdp->cpb, in_crc, INIT_CRC);
> + put32(cmdp->cpb, in_adler, INIT_ADLER);
> + put32(cmdp->cpb, out_crc, INIT_CRC);
> + put32(cmdp->cpb, out_adler, INIT_ADLER);
> +
> + /* Assuming 10% compression ratio initially; use the
> + * most recently measured compression ratio as a
> + * heuristic to estimate the input and output
> + * sizes. If we give too much input, the target buffer
> + * overflows and NX cycles are wasted, and then we
> + * must retry with smaller input size. 1000 is 100%.
> + */
> + last_comp_ratio = 100UL;
> + }
> + cmdp->crb.gzip_fc = 0;
> + putnn(cmdp->crb, gzip_fc, fc);
> +
> + /*
> + * NX source buffers
> + */
> + first_used = fifo_used_first_bytes(cur_in, used_in, fifo_in_len);
> + last_used = fifo_used_last_bytes(cur_in, used_in, fifo_in_len);
> +
> + if (first_used > 0)
> + nx_append_dde(ddl_in, fifo_in + cur_in, first_used);
> +
> + if (last_used > 0)
> + nx_append_dde(ddl_in, fifo_in, last_used);
> +
> + /*
> + * NX target buffers
> + */
> + first_free = fifo_free_first_bytes(cur_out, used_out, fifo_out_len);
> + last_free = fifo_free_last_bytes(cur_out, used_out, fifo_out_len);
> +
> + /* Reduce output free space amount not to overwrite the history */
> + int target_max = NX_MAX(0, fifo_free_bytes(used_out, fifo_out_len)
> + - (1<<16));
> +
> + NXPRT(fprintf(stderr, "target_max %d (0x%x)\n", target_max,
> + target_max));
> +
> + first_free = NX_MIN(target_max, first_free);
> + if (first_free > 0) {
> + first_offset = fifo_free_first_offset(cur_out, used_out);
> + nx_append_dde(ddl_out, fifo_out + first_offset, first_free);
> + }
> +
> + if (last_free > 0) {
> + last_free = NX_MIN(target_max - first_free, last_free);
> + if (last_free > 0) {
> + last_offset = fifo_free_last_offset(cur_out, used_out,
> + fifo_out_len);
> + nx_append_dde(ddl_out, fifo_out + last_offset,
> + last_free);
> + }
> + }
> +
> + /* Target buffer size is used to limit the source data size
> + * based on previous measurements of compression ratio.
> + */
> +
> + /* source_sz includes history */
> + source_sz = getp32(ddl_in, ddebc);
> + assert(source_sz > history_len);
> + source_sz = source_sz - history_len;
> +
> + /* Estimating how much source is needed to 3/4 fill a
> + * target_max size target buffer. If we overshoot, then NX
> + * must repeat the job with smaller input and we waste
> + * bandwidth. If we undershoot then we use more NX calls than
> + * necessary.
> + */
> +
> + source_sz_estimate = ((uint64_t)target_max * last_comp_ratio * 3UL)
> + / 4000;
> +
> + if (source_sz_estimate < source_sz) {
> + /* Target might be small, therefore limiting the
> + * source data.
> + */
> + source_sz = source_sz_estimate;
> + target_sz_estimate = target_max;
> + } else {
> + /* Source file might be small, therefore limiting target
> + * touch pages to a smaller value to save processor cycles.
> + */
> + target_sz_estimate = ((uint64_t)source_sz * 1000UL)
> + / (last_comp_ratio + 1);
> + target_sz_estimate = NX_MIN(2 * target_sz_estimate,
> + target_max);
> + }
> +
> + source_sz = source_sz + history_len;
> +
> + /* Some NX condition codes require submitting the NX job again.
> + * Kernel doesn't handle NX page faults. Expects user code to
> + * touch pages.
> + */
> + pgfault_retries = retry_max;
> +
> +restart_nx:
> +
> + putp32(ddl_in, ddebc, source_sz);
> +
> + /* Fault in pages */
> + nx_touch_pages_dde(ddl_in, 0, page_sz, 0);
> + nx_touch_pages_dde(ddl_out, target_sz_estimate, page_sz, 1);
> +
> + /* Send job to NX */
> + cc = nx_submit_job(ddl_in, ddl_out, cmdp, devhandle);
> +
> + switch (cc) {
> +
> + case ERR_NX_TRANSLATION:
> +
> + /* We touched the pages ahead of time. In the most common case
> + * we shouldn't be here. But may be some pages were paged out.
> + * Kernel should have placed the faulting address to fsaddr.
> + */
> + NXPRT(fprintf(stderr, "ERR_NX_TRANSLATION %p\n",
> + (void *)cmdp->crb.csb.fsaddr));
> +
> + /* Touch 1 byte, read-only */
> + nx_touch_pages((void *)cmdp->crb.csb.fsaddr, 1, page_sz, 0);
> +
> + if (pgfault_retries == retry_max) {
> + /* Try once with exact number of pages */
> + --pgfault_retries;
> + goto restart_nx;
> + } else if (pgfault_retries > 0) {
> + /* If still faulting try fewer input pages
> + * assuming memory outage
> + */
> + if (source_sz > page_sz)
> + source_sz = NX_MAX(source_sz / 2, page_sz);
> + --pgfault_retries;
> + goto restart_nx;
> + } else {
> + fprintf(stderr, "cannot make progress; too many page \
> + fault retries cc= %d\n", cc);
> + rc = -1;
> + goto err5;
> + }
> +
> + case ERR_NX_DATA_LENGTH:
> +
> + NXPRT(fprintf(stderr, "ERR_NX_DATA_LENGTH; not an error \
> + usually; stream may have trailing data\n"));
> +
> + /* Not an error in the most common case; it just says
> + * there is trailing data that we must examine.
> + *
> + * CC=3 CE(1)=0 CE(0)=1 indicates partial completion
> + * Fig.6-7 and Table 6-8.
> + */
> + nx_ce = get_csb_ce_ms3b(cmdp->crb.csb);
> +
> + if (!csb_ce_termination(nx_ce) &&
> + csb_ce_partial_completion(nx_ce)) {
> + /* Check CPB for more information
> + * spbc and tpbc are valid
> + */
> + sfbt = getnn(cmdp->cpb, out_sfbt); /* Table 6-4 */
> + subc = getnn(cmdp->cpb, out_subc); /* Table 6-4 */
> + spbc = get32(cmdp->cpb, out_spbc_decomp);
> + tpbc = get32(cmdp->crb.csb, tpbc);
> + assert(target_max >= tpbc);
> +
> + goto ok_cc3; /* not an error */
> + } else {
> + /* History length error when CE(1)=1 CE(0)=0. */
> + rc = -1;
> + fprintf(stderr, "history length error cc= %d\n", cc);
> + goto err5;
> + }
> +
> + case ERR_NX_TARGET_SPACE:
> +
> + /* Target buffer not large enough; retry smaller input
> + * data; give at least 1 byte. SPBC/TPBC are not valid.
> + */
> + assert(source_sz > history_len);
> + source_sz = ((source_sz - history_len + 2) / 2) + history_len;
> + NXPRT(fprintf(stderr, "ERR_NX_TARGET_SPACE; retry with \
> + smaller input data src %d hist %d\n", source_sz,
> + history_len));
> + goto restart_nx;
> +
> + case ERR_NX_OK:
> +
> + /* This should not happen for gzip formatted data;
> + * we need trailing crc and isize
> + */
> + fprintf(stderr, "ERR_NX_OK\n");
> + spbc = get32(cmdp->cpb, out_spbc_decomp);
> + tpbc = get32(cmdp->crb.csb, tpbc);
> + assert(target_max >= tpbc);
> + assert(spbc >= history_len);
> + source_sz = spbc - history_len;
> + goto offsets_state;
> +
> + default:
> + fprintf(stderr, "error: cc= %d\n", cc);
> + rc = -1;
> + goto err5;
> + }
> +
> +ok_cc3:
> +
> + NXPRT(fprintf(stderr, "cc3: sfbt: %x\n", sfbt));
> +
> + assert(spbc > history_len);
> + source_sz = spbc - history_len;
> +
> + /* Table 6-4: Source Final Block Type (SFBT) describes the
> + * last processed deflate block and clues the software how to
> + * resume the next job. SUBC indicates how many input bits NX
> + * consumed but did not process. SPBC indicates how many
> + * bytes of source were given to the accelerator including
> + * history bytes.
> + */
> +
> + switch (sfbt) {
> + int dhtlen;
> +
> + case 0b0000: /* Deflate final EOB received */
> +
> + /* Calculating the checksum start position. */
> +
> + source_sz = source_sz - subc / 8;
> + is_final = 1;
> + break;
> +
> + /* Resume decompression cases are below. Basically
> + * indicates where NX has suspended and how to resume
> + * the input stream.
> + */
> +
> + case 0b1000: /* Within a literal block; use rembytecount */
> + case 0b1001: /* Within a literal block; use rembytecount; bfinal=1 */
> +
> + /* Supply the partially processed source byte again */
> + source_sz = source_sz - ((subc + 7) / 8);
> +
> + /* SUBC LS 3bits: number of bits in the first source byte need
> + * to be processed.
> + * 000 means all 8 bits; Table 6-3
> + * Clear subc, histlen, sfbt, rembytecnt, dhtlen
> + */
> + cmdp->cpb.in_subc = 0;
> + cmdp->cpb.in_sfbt = 0;
> + putnn(cmdp->cpb, in_subc, subc % 8);
> + putnn(cmdp->cpb, in_sfbt, sfbt);
> + putnn(cmdp->cpb, in_rembytecnt, getnn(cmdp->cpb,
> + out_rembytecnt));
> + break;
> +
> + case 0b1010: /* Within a FH block; */
> + case 0b1011: /* Within a FH block; bfinal=1 */
> +
> + source_sz = source_sz - ((subc + 7) / 8);
> +
> + /* Clear subc, histlen, sfbt, rembytecnt, dhtlen */
> + cmdp->cpb.in_subc = 0;
> + cmdp->cpb.in_sfbt = 0;
> + putnn(cmdp->cpb, in_subc, subc % 8);
> + putnn(cmdp->cpb, in_sfbt, sfbt);
> + break;
> +
> + case 0b1100: /* Within a DH block; */
> + case 0b1101: /* Within a DH block; bfinal=1 */
> +
> + source_sz = source_sz - ((subc + 7) / 8);
> +
> + /* Clear subc, histlen, sfbt, rembytecnt, dhtlen */
> + cmdp->cpb.in_subc = 0;
> + cmdp->cpb.in_sfbt = 0;
> + putnn(cmdp->cpb, in_subc, subc % 8);
> + putnn(cmdp->cpb, in_sfbt, sfbt);
> +
> + dhtlen = getnn(cmdp->cpb, out_dhtlen);
> + putnn(cmdp->cpb, in_dhtlen, dhtlen);
> + assert(dhtlen >= 42);
> +
> + /* Round up to a qword */
> + dhtlen = (dhtlen + 127) / 128;
> +
> + while (dhtlen > 0) { /* Copy dht from cpb.out to cpb.in */
> + --dhtlen;
> + cmdp->cpb.in_dht[dhtlen] = cmdp->cpb.out_dht[dhtlen];
> + }
> + break;
> +
> + case 0b1110: /* Within a block header; bfinal=0; */
> + /* Also given if source data exactly ends (SUBC=0) with
> + * EOB code with BFINAL=0. Means the next byte will
> + * contain a block header.
> + */
> + case 0b1111: /* within a block header with BFINAL=1. */
> +
> + source_sz = source_sz - ((subc + 7) / 8);
> +
> + /* Clear subc, histlen, sfbt, rembytecnt, dhtlen */
> + cmdp->cpb.in_subc = 0;
> + cmdp->cpb.in_sfbt = 0;
> + putnn(cmdp->cpb, in_subc, subc % 8);
> + putnn(cmdp->cpb, in_sfbt, sfbt);
> + }
> +
> +offsets_state:
> +
> + /* Adjust the source and target buffer offsets and lengths */
> +
> + NXPRT(fprintf(stderr, "offsets_state:\n"));
> +
> + /* Delete input data from fifo_in */
> + used_in = used_in - source_sz;
> + cur_in = (cur_in + source_sz) % fifo_in_len;
> + input_file_offset = input_file_offset + source_sz;
> +
> + /* Add output data to fifo_out */
> + used_out = used_out + tpbc;
> +
> + assert(used_out <= fifo_out_len);
> +
> + total_out = total_out + tpbc;
> +
> + /* Deflate history is 32KB max. No need to supply more
> + * than 32KB on a resume.
> + */
> + history_len = (total_out > window_max) ? window_max : total_out;
> +
> + /* To estimate expected expansion in the next NX job; 500 means 50%.
> + * Deflate best case is around 1 to 1000.
> + */
> + last_comp_ratio = (1000UL * ((uint64_t)source_sz + 1))
> + / ((uint64_t)tpbc + 1);
> + last_comp_ratio = NX_MAX(NX_MIN(1000UL, last_comp_ratio), 1);
> + NXPRT(fprintf(stderr, "comp_ratio %ld source_sz %d spbc %d tpbc %d\n",
> + last_comp_ratio, source_sz, spbc, tpbc));
> +
> + resuming = 1;
> +
> +finish_state:
> +
> + NXPRT(fprintf(stderr, "finish_state:\n"));
> +
> + if (is_final) {
> + if (used_out)
> + goto write_state; /* More data to write out */
> + else if (used_in < 8) {
> + /* Need at least 8 more bytes containing gzip crc
> + * and isize.
> + */
> + rc = -1;
> + goto err4;
> + } else {
> + /* Compare checksums and exit */
> + int i;
> + char tail[8];
> + uint32_t cksum, isize;
> + for (i = 0; i < 8; i++)
> + tail[i] = fifo_in[(cur_in + i) % fifo_in_len];
> + fprintf(stderr, "computed checksum %08x isize %08x\n",
> + cmdp->cpb.out_crc, (uint32_t) (total_out
> + % (1ULL<<32)));
> + cksum = (tail[0] | tail[1]<<8 | tail[2]<<16
> + | tail[3]<<24);
> + isize = (tail[4] | tail[5]<<8 | tail[6]<<16
> + | tail[7]<<24);
> + fprintf(stderr, "stored checksum %08x isize %08x\n",
> + cksum, isize);
> +
> + if (cksum == cmdp->cpb.out_crc && isize == (uint32_t)
> + (total_out % (1ULL<<32))) {
> + rc = 0; goto ok1;
> + } else {
> + rc = -1; goto err4;
> + }
> + }
> + } else
> + goto read_state;
> +
> + return -1;
> +
> +err1:
> + fprintf(stderr, "error: not a gzip file, expect %x, read %x\n",
> + expect, c);
> + return -1;
> +
> +err2:
> + fprintf(stderr, "error: the FLG byte is wrong or not handled by this \
> + code sample\n");
> + return -1;
> +
> +err3:
> + fprintf(stderr, "error: gzip header\n");
> + return -1;
> +
> +err4:
> + fprintf(stderr, "error: checksum\n");
> +
> +err5:
> +ok1:
> + fprintf(stderr, "decomp is complete: fclose\n");
> + fclose(outf);
> +
> + return rc;
> +}
> +
> +
> +int main(int argc, char **argv)
> +{
> + int rc;
> + struct sigaction act;
> + void *handle;
> +
> + act.sa_handler = 0;
> + act.sa_sigaction = sigsegv_handler;
> + act.sa_flags = SA_SIGINFO;
> + act.sa_restorer = 0;
> + sigemptyset(&act.sa_mask);
> + sigaction(SIGSEGV, &act, NULL);
> +
> + handle = nx_function_begin(NX_FUNC_COMP_GZIP, 0);
> + if (!handle) {
> + fprintf(stderr, "Unable to init NX, errno %d\n", errno);
> + exit(-1);
> + }
> +
> + rc = decompress_file(argc, argv, handle);
> +
> + nx_function_end(handle);
> +
> + return rc;
> +}
> --
> 2.21.0
More information about the Linuxppc-dev
mailing list