Initial commit for the SC17 paper version

CMakeLists.txt

+cmake_minimum_required(VERSION 2.8)
+
+find_package(MPI REQUIRED)
+
+project(PAPYRUS)
+
+set(PAPYRUS_VERSION_MAJOR 1)
+set(PAPYRUS_VERSION_MINOR 0)
+set(PAPYRUS_VERSION_PATCH 0)
+
+cmake_host_system_information(RESULT MACHINE QUERY HOSTNAME)
+
+if(${MACHINE} MATCHES "summitdev*")
+    message(STATUS "Configuration for SUMMITDEV")
+    include(conf/summitdev.cmake)
+elseif(${MACHINE} MATCHES "cori*|nid*")
+    message(STATUS "Configuration for CORI")
+    include(conf/cori.cmake)
+else()
+    message(STATUS "Configuration for DEFAULT")
+    include(conf/default.cmake)
+endif()
+
+include(CTest)
+
+add_subdirectory(include)
+add_subdirectory(kv)
+

LICENSE.txt

+
+Copyright (c) 2017, UT-Battelle, LLC
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright
+  notice, this list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright
+  notice, this list of conditions and the following disclaimer in the
+  documentation and/or other materials provided with the distribution.
+* Neither the name of Oak Ridge National Laboratory, nor UT-Battelle, LLC, nor
+  the names of its contributors may be used to endorse or promote products
+  derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+

README.md

+**Papyrus is a programming system written at Oak Ridge National Laboratory that provides features for scalable, aggregate, persistent memory in an extreme-scale system for typical HPC usage scenarios.**
+
+Authors: Jungwon Kim (kimj@ornl.gov), Kittisak Sajjapongse (kittisaks@computer.org), Seyong Lee (slee2@ornl.gov), and Jeffrey S. Vetter (vetter@ornl.gov)
+
+# How to build
+You can build Papyrus with CMake and Make:
+$ cmake <papyrus_source_directory> -DCMAKE_INSTALL_PREFIX=<papyrus_install_directory>
+$ make install
+
+# Repository contents
+The public interface is in include/papyrus/*.h.
+
+The Key-Value Store in is kv/.

build.sh

+rm -rf build install
+mkdir build
+cd build
+cmake -DCMAKE_INSTALL_PREFIX=../install ..
+make -j install

conf/cori.cmake

+set(CMAKE_C_COMPILER "CC")
+set(CMAKE_CXX_COMPILER "CC")
+set(CMAKE_C_FLAGS "-craympich-mt")
+set(CMAKE_CXX_FLAGS "-craympich-mt -std=c++11")
+set(MPIEXEC "srun")
+set(MPIEXEC_NUMPROC_FLAG "-n")

conf/default.cmake

+set(CMAKE_C_COMPILER "mpicc")
+set(CMAKE_CXX_COMPILER "mpic++")
+set(CMAKE_C_FLAGS "")
+set(CMAKE_CXX_FLAGS "-O2 -std=c++11")
+set(MPIEXEC "mpirun")
+set(MPIEXEC_NUMPROC_FLAG "-n")

conf/summitdev.cmake

+set(CMAKE_C_COMPILER "mpicc")
+set(CMAKE_CXX_COMPILER "mpic++")
+set(CMAKE_C_FLAGS "")
+set(CMAKE_CXX_FLAGS "-O2 -qlanglvl=extended0x")
+set(MPIEXEC "mpirun")
+set(MPIEXEC_NUMPROC_FLAG "-n")

include/CMakeLists.txt

+add_subdirectory(papyrus)
+

include/papyrus/CMakeLists.txt

+install(FILES bupc.h mpi.h kv.h DESTINATION include/papyrus)

include/papyrus/bupc.h

+#ifndef PAPYRUS_INCLUDE_PAPYRUS_BUPC_H
+#define PAPYRUS_INCLUDE_PAPYRUS_BUPC_H
+
+#include <bupc_extern.h>
+#include <stdio.h>
+
+extern int MPI_Init_thread(int*, char***, int, int*);
+
+int __real_MPI_Init(int* argc, char*** argv);
+
+int __wrap_MPI_Init(int* argc, char*** argv) {
+    int provided;
+    MPI_Init_thread(argc, argv, 3, &provided);
+    if (provided != 3) fprintf(stderr, "[%s:%d] provided[%d]\n", __FILE__, __LINE__, provided);
+    return 0;
+}
+
+#endif /* PAPYRUS_INCLUDE_PAPYRUS_BUPC_H */

include/papyrus/kv.h

+#ifndef PAPYRUS_KV_INC_PAPYRUS_KV_H
+#define PAPYRUS_KV_INC_PAPYRUS_KV_H
+
+#define PAPYRUSKV_OK                        0
+#define PAPYRUSKV_ERR                       -1
+
+#define PAPYRUSKV_MEMTABLE                  (1 << 0)
+#define PAPYRUSKV_SSTABLE                   (1 << 1)
+
+#define PAPYRUSKV_SEQUENTIAL                (1 << 0)
+#define PAPYRUSKV_RELAXED                   (1 << 1)
+
+#define PAPYRUSKV_CREATE                    (1 << 2)
+#define PAPYRUSKV_RDWR                      (1 << 3)
+#define PAPYRUSKV_WRONLY                    (1 << 4)
+#define PAPYRUSKV_RDONLY                    (1 << 5)
+#define PAPYRUSKV_UDONLY                    (1 << 6)
+
+#include <stddef.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct _papyruskv_iter_t {
+    char* key;
+    size_t keylen;
+    char* val;
+    size_t vallen;
+    void* handle;
+};
+typedef struct _papyruskv_iter_t* papyruskv_iter_t;
+
+struct _papyruskv_pos_t {
+    void* handle;
+};
+typedef struct _papyruskv_pos_t papyruskv_pos_t;
+
+typedef int (*papyruskv_hash_fn_t)(const char* key, size_t keylen, size_t nranks);
+typedef int (*papyruskv_update_fn_t)(const char* key, size_t keylen, char** val, size_t* vallen, void* userin, size_t userinlen, void* userout, size_t useroutlen);
+
+typedef struct {
+    size_t keylen;
+    size_t vallen;
+    papyruskv_hash_fn_t hash;
+} papyruskv_option_t;
+
+extern int papyruskv_init(int* argc, char*** argv, const char* repository);
+extern int papyruskv_finalize();
+extern int papyruskv_open(const char* name, int flags, papyruskv_option_t* opt, int* db);
+extern int papyruskv_close(int db);
+extern int papyruskv_put(int db, const char* key, size_t keylen, const char* val, size_t vallen);
+extern int papyruskv_get(int db, const char* key, size_t keylen, char** val, size_t* vallen);
+extern int papyruskv_get_pos(int db, const char* key, size_t keylen, char** val, size_t* vallen, papyruskv_pos_t* pos);
+extern int papyruskv_delete(int db, const char* key, size_t keylen);
+extern int papyruskv_free(void* val);
+extern int papyruskv_fence(int db, int level);
+extern int papyruskv_barrier(int db, int level);
+extern int papyruskv_signal_notify(int signum, int* ranks, int count);
+extern int papyruskv_signal_wait(int signum, int* ranks, int count);
+extern int papyruskv_consistency(int db, int consistency);
+extern int papyruskv_protect(int db, int prot);
+extern int papyruskv_destroy(int db, int* event);
+extern int papyruskv_checkpoint(int db, const char* path, int* event);
+extern int papyruskv_restart(const char* path, const char* name, int flags, papyruskv_option_t* opt, int* db, int* event);
+extern int papyruskv_wait(int db, int event);
+
+extern int papyruskv_hash(int db, papyruskv_hash_fn_t hfn);
+extern int papyruskv_iter_local(int db, papyruskv_iter_t* iter);
+extern int papyruskv_iter_next(int db, papyruskv_iter_t* iter);
+extern int papyruskv_register_update(int db, int fnid, papyruskv_update_fn_t ufn);
+extern int papyruskv_update(int db, const char* key, size_t keylen, papyruskv_pos_t* pos, int fnid, void* userin, size_t userinlen, void* userout, size_t useroutlen);
+
+#ifdef __cplusplus
+} /* end extern "C" */
+#endif
+
+#endif /* PAPYRUS_KV_INC_PAPYRUS_KV_H */

include/papyrus/mpi.h

+#ifndef PAPYRUS_INCLUDE_PAPYRUS_MPI_H
+#define PAPYRUS_INCLUDE_PAPYRUS_MPI_H
+
+#include <mpi.h>
+#include <stdio.h>
+
+#define MPI_Init(ARGC, ARGV)  {                                                 \
+    int provided;                                                               \
+    MPI_Init_thread(ARGC, ARGV, MPI_THREAD_MULTIPLE, &provided);                \
+    if (provided != MPI_THREAD_MULTIPLE)                                        \
+        fprintf(stderr, "MPI_THREAD_MULTIPLE not supported[%d]\n", provided);   \
+}
+
+#endif /* PAPYRUS_INCLUDE_PAPYRUS_MPI_H */

kv/CMakeLists.txt

+add_subdirectory(src)
+add_subdirectory(tests)
+add_subdirectory(bin)
+

kv/apps/meraculous/Debug.h

+#ifndef PAPYRUS_KV_DEBUG_H
+#define PAPYRUS_KV_DEBUG_H
+
+#include <stdio.h>
+
+//#define _TRACE_ENABLE
+#define _CHECK_ENABLE
+#define _DEBUG_ENABLE
+#define _INFO_ENABLE
+#define _ERROR_ENABLE
+#define _TODO_ENABLE
+
+#define _COLOR_DEBUG
+
+#ifdef _COLOR_DEBUG
+#define RED     "\033[22;31m"
+#define GREEN   "\033[22;32m"
+#define YELLOW  "\033[22;33m"
+#define BLUE    "\033[22;34m"
+#define PURPLE  "\033[22;35m"
+#define CYAN    "\033[22;36m"
+#define GRAY    "\033[22;37m"
+#define _RED    "\033[22;41m"
+#define _GREEN  "\033[22;42m"
+#define _YELLOW "\033[22;43m"
+#define _BLUE   "\033[22;44m"
+#define _PURPLE "\033[22;45m"
+#define _CYAN   "\033[22;46m"
+#define _GRAY   "\033[22;47m"
+#define RESET   "\e[m"
+#else
+#define RED
+#define GREEN
+#define YELLOW
+#define BLUE
+#define PURPLE
+#define CYAN
+#define GRAY
+#define _RED
+#define _GREEN
+#define _YELLOW
+#define _BLUE
+#define _PURPLE
+#define _CYAN
+#define _GRAY
+#define RESET
+#endif
+
+extern char nick_[];
+
+#ifdef _TRACE_ENABLE
+#define  _trace(fmt, ...) { printf( BLUE "[T] %s [%s:%d:%s] " fmt RESET "\n", nick_, __FILE__, __LINE__, __func__, __VA_ARGS__); fflush(stdout); }
+#define __trace(fmt, ...) { printf(_BLUE "[T] %s [%s:%d:%s] " fmt RESET "\n", nick_, __FILE__, __LINE__, __func__, __VA_ARGS__); fflush(stdout); }
+#else
+#define  _trace(fmt, ...)
+#define __trace(fmt, ...)
+#endif
+
+#ifdef _CHECK_ENABLE
+#define  _check() { printf( PURPLE "[C] %s [%s:%d:%s]" RESET "\n", nick_, __FILE__, __LINE__, __func__); fflush(stdout); }
+#define __check() { printf(_PURPLE "[C] %s [%s:%d:%s]" RESET "\n", nick_, __FILE__, __LINE__, __func__); fflush(stdout); }
+#else
+#define  _check()
+#define __check()
+#endif
+
+#ifdef _DEBUG_ENABLE
+#define  _debug(fmt, ...) { printf( CYAN "[D] %s [%s:%d:%s] " fmt RESET "\n", nick_, __FILE__, __LINE__, __func__, __VA_ARGS__); fflush(stdout); }
+#define __debug(fmt, ...) { printf(_CYAN "[D] %s [%s:%d:%s] " fmt RESET "\n", nick_, __FILE__, __LINE__, __func__, __VA_ARGS__); fflush(stdout); }
+#else
+#define  _debug(fmt, ...)
+#define __debug(fmt, ...)
+#endif
+
+#ifdef _INFO_ENABLE
+#define  _info(fmt, ...) { printf( YELLOW "[I] %s [%s:%d:%s] " fmt RESET "\n", nick_, __FILE__, __LINE__, __func__, __VA_ARGS__); fflush(stdout); }
+#define __info(fmt, ...) { printf(_YELLOW "[I] %s [%s:%d:%s] " fmt RESET "\n", nick_, __FILE__, __LINE__, __func__, __VA_ARGS__); fflush(stdout); }
+#else
+#define  _info(fmt, ...)
+#define __info(fmt, ...)
+#endif
+
+#ifdef _ERROR_ENABLE
+#define  _error(fmt, ...) { printf( RED "[E] %s [%s:%d:%s] " fmt RESET "\n", nick_, __FILE__, __LINE__, __func__, __VA_ARGS__); fflush(stdout); }
+#define __error(fmt, ...) { printf(_RED "[E] %s [%s:%d:%s] " fmt RESET "\n", nick_, __FILE__, __LINE__, __func__, __VA_ARGS__); fflush(stdout); }
+#else
+#define  _error(fmt, ...)
+#define __error(fmt, ...)
+#endif
+
+#ifdef _TODO_ENABLE
+#define  _todo(fmt, ...) { printf( GREEN "[TODO] %s [%s:%d:%s] " fmt RESET "\n", nick_, __FILE__, __LINE__, __func__, __VA_ARGS__); fflush(stdout); }
+#define __todo(fmt, ...) { printf(_GREEN "[TODO] %s [%s:%d:%s] " fmt RESET "\n", nick_, __FILE__, __LINE__, __func__, __VA_ARGS__); fflush(stdout); }
+#else
+#define  _todo(fmt, ...)
+#define __todo(fmt, ...)
+#endif
+
+#endif /* PAPYRUS_KV_DEBUG_H */

kv/apps/meraculous/Deleter.h

+/****************************************************************/
+/* Parallel Combinatorial BLAS Library (for Graph Computations) */
+/* version 1.2 -------------------------------------------------*/
+/* date: 10/06/2011 --------------------------------------------*/
+/* authors: Aydin Buluc (abuluc@lbl.gov), Adam Lugowski --------*/
+/****************************************************************/
+/*
+Copyright (c) 2011, Aydin Buluc
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+#ifndef _DELETER_H_
+#define _DELETER_H_
+
+#include <iostream>
+using namespace std;
+
+struct DeletePtrIf
+{
+        template<typename T, typename _BinaryPredicate, typename Pred>
+        void operator()(const T *ptr, _BinaryPredicate cond, Pred first, Pred second) const
+        {
+                if(cond(first,second))
+                        delete ptr;
+        }
+};
+
+
+template<typename A>
+void DeleteAll(A arr1)
+{
+        delete [] arr1;
+}
+
+template<typename A, typename B>
+void DeleteAll(A arr1, B arr2)
+{
+        delete [] arr2;
+        DeleteAll(arr1);
+}
+
+template<typename A, typename B, typename C>
+void DeleteAll(A arr1, B arr2, C arr3)
+{
+        delete [] arr3;
+        DeleteAll(arr1, arr2);
+}
+
+template<typename A, typename B, typename C, typename D>
+void DeleteAll(A arr1, B arr2, C arr3, D arr4)
+{
+        delete [] arr4;
+        DeleteAll(arr1, arr2, arr3);
+}
+
+
+template<typename A, typename B, typename C, typename D, typename E>
+void DeleteAll(A arr1, B arr2, C arr3, D arr4, E arr5)
+{
+        delete [] arr5;
+        DeleteAll(arr1, arr2, arr3, arr4);
+}
+
+template<typename A, typename B, typename C, typename D, typename E, typename F>
+void DeleteAll(A arr1, B arr2, C arr3, D arr4, E arr5, F arr6)
+{
+        delete [] arr6;
+        DeleteAll(arr1, arr2, arr3, arr4,arr5);
+}
+
+#endif

kv/apps/meraculous/Friends.h

+#ifndef _FRIENDS_H_
+#define _FRIENDS_H_
+
+#include <iostream>
+#include <vector>
+#include <string>
+#include <algorithm>
+#include <fstream>
+#include <sstream>
+#include "Kmer.hpp"
+#include "KmerIterator.hpp"
+#include "Deleter.h"
+
+#include <sys/stat.h>
+
+using namespace std;
+
+#ifndef MAX_KMER_SIZE
+#define MAX_KMER_SIZE 64
+#endif
+#define KMERLONGS MAX_KMER_SIZE/32	// 32 = numbits(uint64_t)/2-  with 2 being the number of bits needed per nucleotide
+
+typedef array<uint64_t, KMERLONGS> MERARR;
+
+
+struct filedata
+{
+    char filename[256];
+    size_t filesize;
+};
+
+
+ostream & operator<<(ostream & os, uint8_t val)
+{
+    return os << static_cast<int>(val);
+}
+
+struct kmerpack	// the pair<MERARR,int> used as value_type in map is not guaranteed to be contiguous in memory
+{
+	MERARR arr;
+	int count;
+
+	bool operator > (const kmerpack & rhs) const
+	{ return (arr > rhs.arr); }
+	bool operator < (const kmerpack & rhs) const
+	{ return (arr < rhs.arr); }
+	bool operator == (const kmerpack & rhs) const
+	{ return (arr == rhs.arr); }
+};
+
+
+struct ufxpack	// 38bytes for k=51
+{
+	MERARR arr;	// ~128-bits=16bytes for k=51
+	int count;
+	char left;
+	char right;
+	int leftmin;
+	int leftmax;
+	int rightmin;
+	int rightmax;
+
+	bool operator > (const ufxpack & rhs) const
+	{ return (arr > rhs.arr); }
+	bool operator < (const ufxpack & rhs) const
+	{ return (arr < rhs.arr); }
+	bool operator == (const ufxpack & rhs) const
+	{ return (arr == rhs.arr); }
+};
+
+void PackIntoUFX(array<int,4> & leftcnt, array<int,4> & righcnt, int count, ufxpack & pack)
+{
+	pair<int, char> lsort[4] = {make_pair(leftcnt[0], 'A'), make_pair(leftcnt[1], 'C'), make_pair(leftcnt[2], 'G'), make_pair(leftcnt[3], 'T')};
+	pair<int, char> rsort[4] = {make_pair(righcnt[0], 'A'), make_pair(righcnt[1], 'C'), make_pair(righcnt[2], 'G'), make_pair(righcnt[3], 'T')};
+	sort(lsort, lsort+4);
+	sort(rsort, rsort+4);
+
+	pack.left = lsort[3].second;	// max entry guarenteed to exist
+	pack.leftmax = lsort[3].first;
+	pack.leftmin = lsort[2].first;
+
+	pack.right = rsort[3].second;
+	pack.rightmax = rsort[3].first;
+	pack.rightmin = rsort[2].first;
+
+	pack.count = count;
+}
+
+
+struct SNPdata
+{
+	MERARR karr;
+	char extA;
+	char extB;
+
+	bool operator > (const SNPdata & rhs) const
+	{ return (karr > rhs.karr); }
+	bool operator < (const SNPdata & rhs) const
+	{ return (karr < rhs.karr); }
+	bool operator == (const SNPdata & rhs) const
+	{ return (karr == rhs.karr); }
+};
+
+#endif

kv/apps/meraculous/Kmer.cpp

+#include "Kmer.hpp"
+#include <bitset>
+#include <string>
+#include <iostream>
+
+using namespace std;
+
+/*// use:  int2bin(a, buffer, buf_size);
+// pre:  buf_size >= 8 and buffer has space for buf_size elements
+// post: buffer[0,...,7] is the binary representation of a
+void int2bin(uint32_t a, char *buffer, int buf_size) {
+  //buffer += (buf_size - 1);
+
+  for (int i = 7; i >= 0; i--) {
+      *buffer++ = (a & 1) + '0';
+      a >>= 1;
+  }
+}
+*/
+
+static const uint64_t twin_table[256] = {
+0xFF, 0xBF, 0x7F, 0x3F, 0xEF, 0xAF, 0x6F, 0x2F,
+0xDF, 0x9F, 0x5F, 0x1F, 0xCF, 0x8F, 0x4F, 0x0F,
+0xFB, 0xBB, 0x7B, 0x3B, 0xEB, 0xAB, 0x6B, 0x2B,
+0xDB, 0x9B, 0x5B, 0x1B, 0xCB, 0x8B, 0x4B, 0x0B,
+0xF7, 0xB7, 0x77, 0x37, 0xE7, 0xA7, 0x67, 0x27,
+0xD7, 0x97, 0x57, 0x17, 0xC7, 0x87, 0x47, 0x07,
+0xF3, 0xB3, 0x73, 0x33, 0xE3, 0xA3, 0x63, 0x23,
+0xD3, 0x93, 0x53, 0x13, 0xC3, 0x83, 0x43, 0x03,
+0xFE, 0xBE, 0x7E, 0x3E, 0xEE, 0xAE, 0x6E, 0x2E,
+0xDE, 0x9E, 0x5E, 0x1E, 0xCE, 0x8E, 0x4E, 0x0E,
+0xFA, 0xBA, 0x7A, 0x3A, 0xEA, 0xAA, 0x6A, 0x2A,
+0xDA, 0x9A, 0x5A, 0x1A, 0xCA, 0x8A, 0x4A, 0x0A,
+0xF6, 0xB6, 0x76, 0x36, 0xE6, 0xA6, 0x66, 0x26,
+0xD6, 0x96, 0x56, 0x16, 0xC6, 0x86, 0x46, 0x06,
+0xF2, 0xB2, 0x72, 0x32, 0xE2, 0xA2, 0x62, 0x22,
+0xD2, 0x92, 0x52, 0x12, 0xC2, 0x82, 0x42, 0x02,
+0xFD, 0xBD, 0x7D, 0x3D, 0xED, 0xAD, 0x6D, 0x2D,
+0xDD, 0x9D, 0x5D, 0x1D, 0xCD, 0x8D, 0x4D, 0x0D,
+0xF9, 0xB9, 0x79, 0x39, 0xE9, 0xA9, 0x69, 0x29,
+0xD9, 0x99, 0x59, 0x19, 0xC9, 0x89, 0x49, 0x09,
+0xF5, 0xB5, 0x75, 0x35, 0xE5, 0xA5, 0x65, 0x25,
+0xD5, 0x95, 0x55, 0x15, 0xC5, 0x85, 0x45, 0x05,
+0xF1, 0xB1, 0x71, 0x31, 0xE1, 0xA1, 0x61, 0x21,
+0xD1, 0x91, 0x51, 0x11, 0xC1, 0x81, 0x41, 0x01,
+0xFC, 0xBC, 0x7C, 0x3C, 0xEC, 0xAC, 0x6C, 0x2C,
+0xDC, 0x9C, 0x5C, 0x1C, 0xCC, 0x8C, 0x4C, 0x0C,
+0xF8, 0xB8, 0x78, 0x38, 0xE8, 0xA8, 0x68, 0x28,
+0xD8, 0x98, 0x58, 0x18, 0xC8, 0x88, 0x48, 0x08,
+0xF4, 0xB4, 0x74, 0x34, 0xE4, 0xA4, 0x64, 0x24,
+0xD4, 0x94, 0x54, 0x14, 0xC4, 0x84, 0x44, 0x04,
+0xF0, 0xB0, 0x70, 0x30, 0xE0, 0xA0, 0x60, 0x20,
+0xD0, 0x90, 0x50, 0x10, 0xC0, 0x80, 0x40, 0x00
+};
+
+
+/*static const uint8_t base_swap[256] = {
+	0x00, 0x40, 0x80, 0xc0, 0x10, 0x50, 0x90, 0xd0,
+	0x20, 0x60, 0xa0, 0xe0, 0x30, 0x70, 0xb0, 0xf0,
+	0x04, 0x44, 0x84, 0xc4, 0x14, 0x54, 0x94, 0xd4,
+	0x24, 0x64, 0xa4, 0xe4, 0x34, 0x74, 0xb4, 0xf4,
+	0x08, 0x48, 0x88, 0xc8, 0x18, 0x58, 0x98, 0xd8,
+	0x28, 0x68, 0xa8, 0xe8, 0x38, 0x78, 0xb8, 0xf8,
+	0x0c, 0x4c, 0x8c, 0xcc, 0x1c, 0x5c, 0x9c, 0xdc,
+	0x2c, 0x6c, 0xac, 0xec, 0x3c, 0x7c, 0xbc, 0xfc,
+	0x01, 0x41, 0x81, 0xc1, 0x11, 0x51, 0x91, 0xd1,
+	0x21, 0x61, 0xa1, 0xe1, 0x31, 0x71, 0xb1, 0xf1,
+	0x05, 0x45, 0x85, 0xc5, 0x15, 0x55, 0x95, 0xd5,