gen.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import itertools\n",
    "import collections"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pathlib import Path"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "MAX_BITS = 64\n",
    "TOTAL_BITS = MAX_BITS + 8\n",
    "FIELDS = 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_bit_layouts(num_fields, max_bits, total_bits):\n",
    "    q = collections.deque([()])\n",
    "    item = q.popleft()\n",
    "    while len(item) < num_fields:\n",
    "        upper_bound = min(total_bits - sum(item), max_bits)\n",
    "        if len(item) == num_fields - 1:\n",
    "            q.append(item + (upper_bound,))\n",
    "        else:\n",
    "            lower_bound = max(0, total_bits - sum(item) - (num_fields - len(item) - 1) * max_bits)\n",
    "            q.extend([item + (x,) for x in range(lower_bound, upper_bound + 1)])\n",
    "        item = q.popleft()\n",
    "    q.appendleft(item)\n",
    "    return q"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bit_layouts_all = get_bit_layouts(FIELDS, MAX_BITS, TOTAL_BITS)\n",
    "bit_layouts = list(filter(lambda bl: (MAX_BITS in bl) or (MAX_BITS - 1 in bl), bit_layouts_all))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(bit_layouts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set(map(sum, bit_layouts))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fill_zeros(n):\n",
    "    return '0' * n\n",
    "def fill_ones(n):\n",
    "    return '1' * n\n",
    "\n",
    "def get_fill_repeat(seq):\n",
    "    len_seq = len(seq)\n",
    "    return (lambda n: seq * (n // len_seq) + seq[:(n % len_seq if n >= 0 else 0)])\n",
    "def get_fill_prefix_and_existing(prefix, func):\n",
    "    len_prefix = len(prefix)\n",
    "    return (lambda n: prefix[:max(0, n)] + func(n - len_prefix))\n",
    "def get_fill_existing_and_suffix(func, suffix):\n",
    "    len_suffix = len(suffix)\n",
    "    return (lambda n: func(n - len_suffix) + (suffix[-n:] if n >= 1 else ''))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "def fill_random(n):\n",
    "    return f'{random.getrandbits(n):0{n}b}' if n > 0 else ''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fill_patterns = [\n",
    "    fill_zeros,\n",
    "    # get_fill_existing_and_suffix(fill_zeros, '1'),\n",
    "    # get_fill_prefix_and_existing('00', fill_ones),\n",
    "    get_fill_prefix_and_existing('0', fill_ones),\n",
    "    # get_fill_repeat('01'),\n",
    "    # get_fill_repeat('10'),\n",
    "    # get_fill_repeat('1000''0000'),\n",
    "    get_fill_prefix_and_existing('1', fill_zeros),\n",
    "    fill_ones,\n",
    "]\n",
    "fill_patterns += (fill_random,) * 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_values = [-1, 0, 1, 2, 3, 6, 16]\n",
    "results = []\n",
    "for func in fill_patterns:\n",
    "    results.append({'pattern': func, 'results': [func(n) for n in test_values]})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fillings_by_num_bits = {n: sorted(set([func(n) for func in fill_patterns])) for n in range(0, MAX_BITS + 1)}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fillings_by_num_bits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bit_layouts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "target_dir = Path(\"\"\"R:\\Temp\"\"\")\n",
    "target_dir_ksy = target_dir / 'ksy'\n",
    "target_dir_kst = target_dir / 'kst'\n",
    "target_dir_bin = target_dir / 'src'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for t_dir in (target_dir_ksy, target_dir_kst, target_dir_bin):\n",
    "    t_dir.mkdir(exist_ok=True)\n",
    "    if t_dir in (target_dir_ksy, target_dir_kst):\n",
    "        for bit_endian in ('be', 'le'):\n",
    "            (t_dir / bit_endian).mkdir(exist_ok=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert TOTAL_BITS % 8 == 0, 'TOTAL_BITS ({:d}) not divisible by 8'.format(TOTAL_BITS)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_tests = 0\n",
    "\n",
    "for bit_layout in bit_layouts:\n",
    "    ksy_id = ''.join(map(lambda n: f'b{n:d}', bit_layout))\n",
    "    layout_data = itertools.product(*[enumerate(fillings_by_num_bits[n]) for n in bit_layout])\n",
    "\n",
    "    ksy_seq = ''\n",
    "    for j, bits in enumerate(bit_layout):\n",
    "        ksy_seq += f\"\"\"\\\n",
    "  - id: {chr(ord('a') + j)}\n",
    "    type: b{bits:d}\n",
    "\"\"\"\n",
    "\n",
    "    for bit_endian in (\n",
    "        'be',\n",
    "        'le',\n",
    "    ):\n",
    "        ksy_code = f\"\"\"\\\n",
    "meta:\n",
    "  id: {ksy_id}\n",
    "  bit-endian: {bit_endian}\n",
    "seq:\n",
    "\"\"\"\n",
    "        ksy_code += ksy_seq\n",
    "        with open(target_dir_ksy / bit_endian / f'{ksy_id}.ksy', 'w', encoding='utf-8') as f_ksy:\n",
    "            f_ksy.write(ksy_code)\n",
    "\n",
    "    for val_pairs in layout_data:\n",
    "        num_tests += 1\n",
    "        filling_id_parts, vals = zip(*val_pairs)\n",
    "        test_id = ksy_id +  '_v' + 'x'.join(map(str, filling_id_parts))\n",
    "\n",
    "        kst_asserts = ''\n",
    "        for j, val in enumerate(vals):\n",
    "            val_int = int(val, 2) if val != '' else 0\n",
    "            if len(val) == 1:\n",
    "                val = ('false', 'true')[val_int]\n",
    "            else:\n",
    "                val = f'0x{val_int:_x}' if val_int != 0 else '0'\n",
    "            kst_asserts += f\"\"\"\\\n",
    "  - actual: {chr(ord('a') + j)}\n",
    "    expected: {val}\n",
    "\"\"\"\n",
    "\n",
    "        for bit_endian in (\n",
    "            'be',\n",
    "            'le',\n",
    "        ):\n",
    "            payload = \\\n",
    "                int(''.join(reversed(vals) if bit_endian == 'le' else vals), 2) \\\n",
    "                .to_bytes(TOTAL_BITS // 8, byteorder=('little' if bit_endian == 'le' else 'big'))\n",
    "            payload_fname = payload.hex('_') + '.bin'\n",
    "            try:\n",
    "                with open(target_dir_bin / payload_fname, 'xb') as f_bin:\n",
    "                    f_bin.write(payload)\n",
    "            except FileExistsError:\n",
    "                pass\n",
    "\n",
    "            kst_code = f\"\"\"\\\n",
    "id: {ksy_id}\n",
    "data: {payload_fname}\n",
    "asserts:\n",
    "\"\"\"\n",
    "            kst_code += kst_asserts\n",
    "\n",
    "            kst_dir = target_dir_kst / bit_endian\n",
    "            with open(kst_dir / f'{test_id}.kst', 'w', encoding='utf-8') as f_kst:\n",
    "                f_kst.write(kst_code)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('{:_d}'.format(num_tests))"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "d665d7d870a39c1fa4c36bb272cd4291e4395d800b42d24d9e4803d9ab919915"
  },
  "kernelspec": {
   "display_name": "Python 3.9.6 64-bit",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.6"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}