Jingga/cOMS
1
0
Fork 0
mirror of https://github.com/Karaka-Management/cOMS.git synced 2026-02-15 18:08:40 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

test namespace only

Browse Source
This commit is contained in:
Dennis Eichhorn 2022-09-17 01:00:19 +02:00
parent 24cf23f026
commit 04ab177b23
4 changed files with 258 additions and 277 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

154
Hash/MeowHash.h
View File

@ -117,56 +117,53 @@
namespace Hash { namespace Hash {
namespace Meow { namespace Meow {
#if !defined(MEOW_HASH_X64_AESNI_H)
#define MEOW_HASH_VERSION 5 #define MEOW_HASH_VERSION 5
#define MEOW_HASH_VERSION_NAME "0.5/calico" #define MEOW_HASH_VERSION_NAME "0.5/calico"
#if !defined(meow_u8) #if !defined(meow_u8)
#if _MSC_VER
#if !defined(__clang__)
#define INSTRUCTION_REORDER_BARRIER _ReadWriteBarrier()
#else
#endif
#if _MSC_VER #include <intrin.h>
#if !defined(__clang__) #else
#define INSTRUCTION_REORDER_BARRIER _ReadWriteBarrier() #include <x86intrin.h>
#else #endif
#endif
#include <intrin.h>
#else
#include <x86intrin.h>
#endif
#define meow_u8 char unsigned #define meow_u8 char unsigned
#define meow_u64 long long unsigned #define meow_u64 long long unsigned
#define meow_u128 __m128i #define meow_u128 __m128i
#if __x86_64__ || _M_AMD64 #if __x86_64__ || _M_AMD64
#define meow_umm long long unsigned #define meow_umm long long unsigned
#define MeowU64From(A, I) (_mm_extract_epi64((A), (I))) #define MeowU64From(A, I) (_mm_extract_epi64((A), (I)))
#elif __i386__ || _M_IX86 #elif __i386__ || _M_IX86
#define meow_umm int unsigned #define meow_umm int unsigned
#define MeowU64From(A, I) (*(meow_u64 *)&(A)) #define MeowU64From(A, I) (*(meow_u64 *)&(A))
#else #else
#error Cannot determine architecture to use! #error Cannot determine architecture to use!
#endif #endif
#define MeowU32From(A, I) (_mm_extract_epi32((A), (I))) #define MeowU32From(A, I) (_mm_extract_epi32((A), (I)))
#define MeowHashesAreEqual(A, B) (_mm_movemask_epi8(_mm_cmpeq_epi8((A), (B))) == 0xFFFF) #define MeowHashesAreEqual(A, B) (_mm_movemask_epi8(_mm_cmpeq_epi8((A), (B))) == 0xFFFF)
#if !defined INSTRUCTION_REORDER_BARRIER #if !defined INSTRUCTION_REORDER_BARRIER
#define INSTRUCTION_REORDER_BARRIER #define INSTRUCTION_REORDER_BARRIER
#endif #endif
#if !defined MEOW_PAGESIZE #if !defined MEOW_PAGESIZE
#define MEOW_PAGESIZE 4096 #define MEOW_PAGESIZE 4096
#endif #endif
#if !defined MEOW_PREFETCH #if !defined MEOW_PREFETCH
#define MEOW_PREFETCH 4096 #define MEOW_PREFETCH 4096
#endif #endif
#if !defined MEOW_PREFETCH_LIMIT
#define MEOW_PREFETCH_LIMIT 0x3ff
#endif
#if !defined MEOW_PREFETCH_LIMIT
#define MEOW_PREFETCH_LIMIT 0x3ff
#endif
#endif #endif
#define prefetcht0(A) _mm_prefetch((char *)(A), _MM_HINT_T0) #define prefetcht0(A) _mm_prefetch((char *)(A), _MM_HINT_T0)
@ -182,52 +179,52 @@ namespace Hash {
#define pxor_clear(A, B) A = _mm_setzero_si128(); // NOTE(casey): pxor_clear is a nonsense thing that is only here because compilers don't detect xor(a, a) is clearing a :( #define pxor_clear(A, B) A = _mm_setzero_si128(); // NOTE(casey): pxor_clear is a nonsense thing that is only here because compilers don't detect xor(a, a) is clearing a :(
#define MEOW_MIX_REG(r1, r2, r3, r4, r5, i1, i2, i3, i4) \ #define MEOW_MIX_REG(r1, r2, r3, r4, r5, i1, i2, i3, i4) \
aesdec(r1, r2); \ aesdec(r1, r2); \
INSTRUCTION_REORDER_BARRIER; \ INSTRUCTION_REORDER_BARRIER; \
paddq(r3, i1); \ paddq(r3, i1); \
pxor(r2, i2); \ pxor(r2, i2); \
aesdec(r2, r4); \ aesdec(r2, r4); \
INSTRUCTION_REORDER_BARRIER; \ INSTRUCTION_REORDER_BARRIER; \
paddq(r5, i3); \ paddq(r5, i3); \
pxor(r4, i4); pxor(r4, i4);
#define MEOW_MIX(r1, r2, r3, r4, r5, ptr) \ #define MEOW_MIX(r1, r2, r3, r4, r5, ptr) \
MEOW_MIX_REG(r1, r2, r3, r4, r5, _mm_loadu_si128( (__m128i *) ((ptr) + 15) ), _mm_loadu_si128( (__m128i *) ((ptr) + 0) ), _mm_loadu_si128( (__m128i *) ((ptr) + 1) ), _mm_loadu_si128( (__m128i *) ((ptr) + 16) )) MEOW_MIX_REG(r1, r2, r3, r4, r5, _mm_loadu_si128( (__m128i *) ((ptr) + 15) ), _mm_loadu_si128( (__m128i *) ((ptr) + 0) ), _mm_loadu_si128( (__m128i *) ((ptr) + 1) ), _mm_loadu_si128( (__m128i *) ((ptr) + 16) ))
#define MEOW_SHUFFLE(r1, r2, r3, r4, r5, r6) \ #define MEOW_SHUFFLE(r1, r2, r3, r4, r5, r6) \
aesdec(r1, r4); \ aesdec(r1, r4); \
paddq(r2, r5); \ paddq(r2, r5); \
pxor(r4, r6); \ pxor(r4, r6); \
aesdec(r4, r2); \ aesdec(r4, r2); \
paddq(r5, r6); \ paddq(r5, r6); \
pxor(r2, r3) pxor(r2, r3)
#if MEOW_DUMP #if MEOW_DUMP
struct meow_dump struct meow_dump
{ {
meow_u128 xmm[8]; meow_u128 xmm[8];
void *Ptr; void *Ptr;
char const *Title; char const *Title;
}; };
extern "C" meow_dump *MeowDumpTo; extern "C" meow_dump *MeowDumpTo;
meow_dump *MeowDumpTo; meow_dump *MeowDumpTo;
#define MEOW_DUMP_STATE(T, xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, ptr) \ #define MEOW_DUMP_STATE(T, xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, ptr) \
if(MeowDumpTo) \ if(MeowDumpTo) \
{ \ { \
MeowDumpTo->xmm[0] = xmm0; \ MeowDumpTo->xmm[0] = xmm0; \
MeowDumpTo->xmm[1] = xmm1; \ MeowDumpTo->xmm[1] = xmm1; \
MeowDumpTo->xmm[2] = xmm2; \ MeowDumpTo->xmm[2] = xmm2; \
MeowDumpTo->xmm[3] = xmm3; \ MeowDumpTo->xmm[3] = xmm3; \
MeowDumpTo->xmm[4] = xmm4; \ MeowDumpTo->xmm[4] = xmm4; \
MeowDumpTo->xmm[5] = xmm5; \ MeowDumpTo->xmm[5] = xmm5; \
MeowDumpTo->xmm[6] = xmm6; \ MeowDumpTo->xmm[6] = xmm6; \
MeowDumpTo->xmm[7] = xmm7; \ MeowDumpTo->xmm[7] = xmm7; \
MeowDumpTo->Ptr = ptr; \ MeowDumpTo->Ptr = ptr; \
MeowDumpTo->Title = T; \ MeowDumpTo->Title = T; \
++MeowDumpTo; \ ++MeowDumpTo; \
} }
#else #else
#define MEOW_DUMP_STATE(...) #define MEOW_DUMP_STATE(...)
#endif #endif
static meow_u8 MeowShiftAdjust[32] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15}; static meow_u8 MeowShiftAdjust[32] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
@ -742,9 +739,6 @@ namespace Hash {
} }
MeowEnd(&State, SeedResult); MeowEnd(&State, SeedResult);
} }
#define MEOW_HASH_X64_AESNI_H
#endif
} }
} }
#endif #endif

52
Utils/ArrayUtils.h
View File

@ -17,38 +17,34 @@
#include "StringUtils.h" #include "StringUtils.h"
namespace Utils { namespace Utils {
class ArrayUtils { namespace ArrayUtils {
private: inline
char* get_arg(const char *id, char **argv, int length)
public: {
static inline if (Utils::StringUtils::is_number(id)) {
char* get_arg(const char *id, char **argv, int length) return argv[atoi(id)];
{
if (Utils::StringUtils::is_number(id)) {
return argv[atoi(id)];
}
for (int i = 0; i < length - 1; ++i) {
if (strcmp(id, argv[i]) == 0) {
return argv[i + 1];
}
}
return NULL;
} }
static inline for (int i = 0; i < length - 1; ++i) {
bool has_arg(const char *id, char **argv, int length) if (strcmp(id, argv[i]) == 0) {
{ return argv[i + 1];
for (int i = 0; i < length; ++i) {
if (strcmp(id, argv[i]) == 0) {
return true;
}
} }
return false;
} }
};
return NULL;
}
inline
bool has_arg(const char *id, char **argv, int length)
{
for (int i = 0; i < length; ++i) {
if (strcmp(id, argv[i]) == 0) {
return true;
}
}
return false;
}
} }
#endif #endif

150
Utils/FileUtils.h
View File

@ -28,95 +28,91 @@
#endif #endif
namespace Utils { namespace Utils {
class FileUtils { namespace FileUtils {
private: inline
bool file_exists (char *filename)
public: {
static inline #ifdef _WIN32
bool file_exists (char *filename) #ifdef _MSC_VER
{ return _access_s(filename, 0) == 0;
#ifdef _WIN32 #else
#ifdef _MSC_VER return access(filename, 0) == 0;
return _access_s(filename, 0) == 0;
#else
return access(filename, 0) == 0;
#endif
#elif defined __linux__
struct stat buffer;
return stat(filename, &buffer) == 0;
#endif #endif
} #elif defined __linux__
struct stat buffer;
return stat(filename, &buffer) == 0;
#endif
}
static inline inline
time_t last_modification (char *filename) time_t last_modification (char *filename)
{ {
#ifdef _WIN32 #ifdef _WIN32
FILETIME modtime; FILETIME modtime;
HANDLE h; HANDLE h;
h = CreateFileW(filename, GENERIC_READ | FILE_WRITE_ATTRIBUTES, 0, NULL, OPEN_EXISTING, 0, NULL); h = CreateFileW(filename, GENERIC_READ | FILE_WRITE_ATTRIBUTES, 0, NULL, OPEN_EXISTING, 0, NULL);
if (h == INVALID_HANDLE_VALUE) { if (h == INVALID_HANDLE_VALUE) {
return (time_t) 0; return (time_t) 0;
}
if (GetFileTime(h, NULL, NULL, &modtime) == 0) {
return (time_t) 0;
}
unsinged long long seconds = modtime.dwHighDateTime << 32;
seconds |= modtime.dwLowDateTime;
return (seconds - 116444736000000000) / 10000000;
#elif defined __linux__
struct stat buffer;
stat(filename, &buffer);
(time_t) buffer.st_mtim.tv_sec;
#endif
}
char* file_extension (char *filename)
{
char *dot = strrchr(filename, '.');
if (!dot || dot == filename) {
return "";
} }
return dot + 1; if (GetFileTime(h, NULL, NULL, &modtime) == 0) {
} return (time_t) 0;
typedef struct {
char *content;
int size;
} file_body;
static inline
file_body read_file (char *filename)
{
file_body file = {0};
FILE *fp = fopen(filename, "rb");
if (!fp) {
return NULL;
} }
fseek(fp, 0, SEEK_END); unsinged long long seconds = modtime.dwHighDateTime << 32;
file.size = ftell(fp); seconds |= modtime.dwLowDateTime;
fseek(fp, 0, SEEK_SET);
file.content = malloc(file.size); return (seconds - 116444736000000000) / 10000000;
if (!file.content) { #elif defined __linux__
fprintf(stderr, "CRITICAL: malloc failed"); struct stat buffer;
} stat(filename, &buffer);
fread(file.content, file.size, 1, fp); (time_t) buffer.st_mtim.tv_sec;
#endif
}
fclose(fp); char* file_extension (char *filename)
{
char *dot = strrchr(filename, '.');
return file; if (!dot || dot == filename) {
return "";
} }
};
return dot + 1;
}
typedef struct {
char *content;
int size;
} file_body;
inline
file_body read_file (char *filename)
{
file_body file = {0};
FILE *fp = fopen(filename, "rb");
if (!fp) {
return NULL;
}
fseek(fp, 0, SEEK_END);
file.size = ftell(fp);
fseek(fp, 0, SEEK_SET);
file.content = malloc(file.size);
if (!file.content) {
fprintf(stderr, "CRITICAL: malloc failed");
}
fread(file.content, file.size, 1, fp);
fclose(fp);
return file;
}
} }
#endif #endif

179
Utils/StringUtils.h
View File

@ -17,130 +17,125 @@
#include "ArraySort.h" #include "ArraySort.h"
namespace Utils { namespace Utils {
class StringUtils { namespace StringUtils {
private: inline
bool is_number(const char *s)
public: {
static inline while (*s != '\0') {
bool is_number(const char *s) if (!isdigit(*s)) {
{ return false;
while (*s != '\0') {
if (!isdigit(*s)) {
return false;
}
++s;
} }
return true; ++s;
} }
typedef struct { return true;
char **values; }
int *masks;
int size;
} text_diff;
static typedef struct {
text_diff computeLCSDiff (char **from, int fromSize, char **to, int toSize) char **values;
{ int *masks;
char **diffValues = malloc(fromSize * toSize * sizeof(char *)); int size;
int *diffMasks = calloc(fromSize * toSize, sizeof(int)); } text_diff;
int *dm = calloc((fromSize + 1) * (toSize + 1), sizeof(int)); text_diff computeLCSDiff (char **from, int fromSize, char **to, int toSize)
{
char **diffValues = malloc(fromSize * toSize * sizeof(char *));
int *diffMasks = calloc(fromSize * toSize, sizeof(int));
if (!diffValues || !diffMasks || !dm) { int *dm = calloc((fromSize + 1) * (toSize + 1), sizeof(int));
fprintf(stderr, "CRITICAL: malloc failed");
if (!diffValues || !diffMasks || !dm) {
fprintf(stderr, "CRITICAL: malloc failed");
}
int i = 0;
int j = 0;
/* Handled with calloc
for (j = 0; j <= toSize; ++j) {
dm[0 + j] = 0;
}
for (i = 1; i <= fromSize; ++i) {
dm[i * fromSize + 0] = 0;
}
*/
for (i = 1; i <= fromSize; ++i) {
for (j = 1; j <= toSize; ++j) {
dm[i * fromSize + j] = strcmp(from[i - 1], to[j - 1]) == 0
? dm[(i - 1) * fromSize + (j - 1)] + 1
: oms_max(dm[(i - 1) * fromSize + j], dm[i * fromSize + (j - 1)]);
} }
}
int i = 0; int diffIndex = 0;
int j = 0;
/* Handled with calloc i = fromSize;
for (j = 0; j <= toSize; ++j) { j = toSize;
dm[0 + j] = 0;
}
for (i = 1; i <= fromSize; ++i) { while (i > 0 || j > 0) {
dm[i * fromSize + 0] = 0; if (j > 0 && dm[i * fromSize + (j - 1)] == dm[i * fromSize + j]) {
} diffValues[diffIndex] = malloc((strlen(to[j - 1]) + 1) * sizeof(char));
*/ if (!diffValues[diffIndex]) {
fprintf(stderr, "CRITICAL: malloc failed");
for (i = 1; i <= fromSize; ++i) {
for (j = 1; j <= toSize; ++j) {
dm[i * fromSize + j] = strcmp(from[i - 1], to[j - 1]) == 0
? dm[(i - 1) * fromSize + (j - 1)] + 1
: oms_max(dm[(i - 1) * fromSize + j], dm[i * fromSize + (j - 1)]);
}
}
int diffIndex = 0;
i = fromSize;
j = toSize;
while (i > 0 || j > 0) {
if (j > 0 && dm[i * fromSize + (j - 1)] == dm[i * fromSize + j]) {
diffValues[diffIndex] = malloc((strlen(to[j - 1]) + 1) * sizeof(char));
if (!diffValues[diffIndex]) {
fprintf(stderr, "CRITICAL: malloc failed");
}
strcpy(diffValues[diffIndex], to[j - 1]);
diffMasks[diffIndex] = 1;
--j;
++diffIndex;
continue;
} }
if (i > 0 && dm[(i - 1) * fromSize + j] == dm[i * fromSize + j]) { strcpy(diffValues[diffIndex], to[j - 1]);
diffValues[diffIndex] = malloc((strlen(from[i - 1]) + 1) * sizeof(char)); diffMasks[diffIndex] = 1;
if (!diffValues[diffIndex]) {
fprintf(stderr, "CRITICAL: malloc failed");
}
strcpy(diffValues[diffIndex], from[i - 1]); --j;
diffMasks[diffIndex] = -1; ++diffIndex;
--i; continue;
++diffIndex; }
continue
}
if (i > 0 && dm[(i - 1) * fromSize + j] == dm[i * fromSize + j]) {
diffValues[diffIndex] = malloc((strlen(from[i - 1]) + 1) * sizeof(char)); diffValues[diffIndex] = malloc((strlen(from[i - 1]) + 1) * sizeof(char));
if (!diffValues[diffIndex]) { if (!diffValues[diffIndex]) {
fprintf(stderr, "CRITICAL: malloc failed"); fprintf(stderr, "CRITICAL: malloc failed");
} }
strcpy(diffValues[diffIndex], from[i - 1]); strcpy(diffValues[diffIndex], from[i - 1]);
diffMasks[diffIndex] = -1;
/* Handled with calloc
diffMasks[diffIndex] = 0;
*/
--i; --i;
--j;
++diffIndex; ++diffIndex;
continue
} }
free(dm); diffValues[diffIndex] = malloc((strlen(from[i - 1]) + 1) * sizeof(char));
if (!diffValues[diffIndex]) {
diffValues = realloc(diffValues, diffIndex * sizeof(char *));
diffMasks = realloc(diffMasks, diffIndex * sizeof(int));
if (!diffValues || !diffMasks) {
fprintf(stderr, "CRITICAL: malloc failed"); fprintf(stderr, "CRITICAL: malloc failed");
} }
ArraySort::reverse_char(diffValues, diffIndex); strcpy(diffValues[diffIndex], from[i - 1]);
ArraySort::reverse_int(diffMasks, diffIndex);
return text_diff { diffValues, diffMasks, diffIndex }; /* Handled with calloc
diffMasks[diffIndex] = 0;
*/
--i;
--j;
++diffIndex;
} }
};
free(dm);
diffValues = realloc(diffValues, diffIndex * sizeof(char *));
diffMasks = realloc(diffMasks, diffIndex * sizeof(int));
if (!diffValues || !diffMasks) {
fprintf(stderr, "CRITICAL: malloc failed");
}
ArraySort::reverse_char(diffValues, diffIndex);
ArraySort::reverse_int(diffMasks, diffIndex);
return text_diff { diffValues, diffMasks, diffIndex };
}
} }
#endif #endif