nm_flypack.h

Go to the documentation of this file.

/*
 * NewMadeleine
 * Copyright (C) 2015-2026 (see AUTHORS file)
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or (at
 * your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 */
 
#include <nm_core_interface.h>
 
#define FLYPACK_CHUNK_SIZE 16
 
struct flypack_data_s
{
  void*buf;
  nm_len_t len;
};
 
static void flypack_traversal(const void*_content, struct nm_data_op_s*p_op)  __attribute__((unused));
 
static const struct nm_data_ops_s flypack_ops =
  {
    .p_traversal = &flypack_traversal
  };
NM_DATA_TYPE(flypack, struct flypack_data_s, &flypack_ops);
 
 
static nm_len_t flypack_chunk_size(void)
{
  static nm_len_t chunk_size = 0;
  if(chunk_size == 0)
    {
      const char*s_chunk_size = getenv("FLYPACK_CHUNK_SIZE");
      if(s_chunk_size != NULL)
        {
          chunk_size = atoi(s_chunk_size);
        }
      else
        {
          chunk_size = FLYPACK_CHUNK_SIZE;
        }
      fprintf(stderr, "# nmad: flypack chunk size = %d\n", (int)chunk_size);
    }
  return chunk_size;
}
 
static void flypack_traversal(const void*_content, struct nm_data_op_s*p_op)
{
  const struct flypack_data_s*content = _content;
  const nm_len_t chunk_size = flypack_chunk_size();
  if(content->len >= chunk_size)
    {
      const nm_len_t chunk_count = content->len / chunk_size;
      NM_DATA_OP_APPLY_LOOP(i, chunk_count, content->buf + 2 * chunk_size * i, chunk_size, p_op);
      if(chunk_count * chunk_size < content->len)
        {
          const nm_len_t remainder = content->len - chunk_count * chunk_size;
          nm_data_op_apply(content->buf + 2 * chunk_size * chunk_count, remainder, p_op);
        }
    }
  else
    {
      nm_data_op_apply(content->buf, content->len, p_op);
    }
}
 
static inline void flypack_import(char*p_flypack_buffer, const char*p_buf, nm_len_t len)
{
  const nm_len_t chunk_size = flypack_chunk_size();
  const nm_len_t nchunks = len / chunk_size;
  int i;
  for(i = 0; i < nchunks; i++)
    {
      memcpy(&p_flypack_buffer[i * 2 * chunk_size], &p_buf[i * chunk_size], chunk_size);
    }
  if(nchunks * chunk_size < len)
    {
      memcpy(&p_flypack_buffer[nchunks * 2 * chunk_size], &p_buf[nchunks * chunk_size], len - nchunks * chunk_size);
    }
}
 
static inline void flypack_export(const char*p_flypack_buffer, char*p_buf, nm_len_t len)
{
  const nm_len_t chunk_size = flypack_chunk_size();
  const nm_len_t nchunks = len / chunk_size;
  int i;
  for(i = 0; i < nchunks; i++)
    {
      memcpy(&p_buf[i * chunk_size], &p_flypack_buffer[i * 2 * chunk_size], chunk_size);
    }
  if(nchunks * chunk_size < len)
    {
      memcpy(&p_buf[nchunks * chunk_size], &p_flypack_buffer[nchunks * 2 * chunk_size], len - nchunks * chunk_size);
    }
}