Changed UDF reader hash to 65536 instead of 16M

The 16M option was used for doing mesh adjacency and it's proven to be working but no longer needed.

la_data.c

@@ -617,10 +617,10 @@ void laset_InstanceUID(void* instance, char* buf){
     if(level!=2||!m) return;
     char _buf[40];
     if(!buf[0]){ memCreateNUID(_buf,m); buf=_buf; }
-    laListHandle *l = hsh16MDoHashNUID(&MAIN.DBInst2, m->NUID.String);
+    laListHandle *l = hsh65536DoHashNUID(&MAIN.DBInst2, m->NUID.String);
     laMemNodeHyper* im=0;
     for (im = l->pFirst; im; im = m->Item.pNext){ if(im==m) break; }
-    if(im){ lstRemoveItem(l,im); laListHandle *nl = hsh16MDoHashNUID(&MAIN.DBInst2, buf); lstAppendItem(nl,im); }else{ im=m; /* Unlikely */ }
+    if(im){ lstRemoveItem(l,im); laListHandle *nl = hsh65536DoHashNUID(&MAIN.DBInst2, buf); lstAppendItem(nl,im); }else{ im=m; /* Unlikely */ }
     sprintf(m->NUID.String,"%.30s",buf);
 }
 void* laget_SaverDummy(void* instance, laPropIterator* pi){
@@ -2951,7 +2951,7 @@ void la_DestroyUDFContentNodeTreeRecursive(laUDFContentNode *ucn, int FreeRoot){
 
 void *la_GetReadDBInstNUID(char *ReferReadNUID){
     if (!ReferReadNUID) return 0;
-    laListHandle *l = hsh16MDoHashNUID(&MAIN.DBInst2, ReferReadNUID);
+    laListHandle *l = hsh65536DoHashNUID(&MAIN.DBInst2, ReferReadNUID);
     for (laMemNodeHyper* m = l->pFirst; m; m = m->Item.pNext){
         if (!strcmp(ReferReadNUID, m->NUID.String))
             return ((unsigned char*)m)+sizeof(laMemNodeHyper);
@@ -2960,7 +2960,7 @@ void *la_GetReadDBInstNUID(char *ReferReadNUID){
 }
 void *la_GetReadDBInstPtr(void *ReferRead){
     if (!ReferRead) return 0;
-    laListHandle *l = hsh16MDoHashLongPtr(&MAIN.DBInst1, ReferRead);
+    laListHandle *l = hsh65536DoHashLongPtr(&MAIN.DBInst1, ReferRead);
     for (laMemNode* m = l->pFirst; m; m = m->Item.pNext){
         if (ReferRead == m->ReadInstance)
             return ((unsigned char*)m)+sizeof(laMemNode);
@@ -2971,8 +2971,8 @@ void la_AddDataInst(void *ReadInstance, char *ReadNUID, void *ActualInstance){
     laListHandle* l=0;
     void* head=memGetHead(ActualInstance, 0);
 
-    if (ReadNUID) l = hsh16MDoHashNUID(&MAIN.DBInst2, ReadNUID);
-    else { l = hsh16MDoHashLongPtr(&MAIN.DBInst1, ReadInstance); ((laMemNode*)head)->ReadInstance = ReadInstance; }
+    if (ReadNUID) l = hsh65536DoHashNUID(&MAIN.DBInst2, ReadNUID);
+    else { l = hsh65536DoHashLongPtr(&MAIN.DBInst1, ReadInstance); ((laMemNode*)head)->ReadInstance = ReadInstance; }
 
     lstPushItem(l, head); //always push so we get the latest during ptr sync.
 }

la_interface.h

@@ -446,9 +446,9 @@ STRUCTURE(LA){
     int TotalByteCount;
 
     laHash65536* DBInstMemLeft;// list item pointers
-    laHash16M DBInst2;
-    laHash16M DBInst1;
-    laHash16M PtrSync;
+    laHash65536 DBInst2;
+    laHash65536 DBInst1;
+    laHash65536 PtrSync;
     laListHandle PtrSyncAddressCommands;
     laListHandle PtrSyncHyper2Commands;
     laListHandle PostReadNodes;

la_util.c

@@ -943,6 +943,12 @@ void lstDestroyElementList(laListHandle *hlst){
     }
 }
 
+uint16_t BKDRHash16bit(char* str){
+    unsigned int seed = 131, hash = 0;
+    while (*str) { hash = hash * seed + (*str++); }
+    return (hash & 0xFFFF);
+}
+
 void hsh65536Init(laHash65536** h){
     if(!h) return; *h=calloc(1,sizeof(laHash65536));
 }
@@ -951,20 +957,11 @@ void hshFree(laHash65536** h){
 }
 
 laListHandle* hsh65536DoHashLongPtr(laHash65536* hash, unsigned long long buckle) {
-	return &hash->Entries[(unsigned short)((buckle >> 10))];
+	return &hash->Entries[(unsigned short)(buckle*13)];
 }
 laListHandle* hsh65536DoHashNUID(laHash65536* hash, char * NUID) {
 	u64bit Hash;
-	sscanf(NUID, "%ld", &Hash);
-	return hsh65536DoHashLongPtr(hash, (long)Hash);
-}
-laListHandle* hsh16MDoHashLongPtr(laHash16M* hash, long long buckle) {
-	return &hash->Entries[(buckle>>6)&0x00FFFFFF];
-}
-laListHandle* hsh16MDoHashNUID(laHash16M* hash, char * NUID) {
-	u64bit Hash=0;
-    for(char* c=NUID;*c;c++){ Hash=Hash*3+(*c); }
-	return hsh65536DoHashLongPtr(hash, (long)Hash);
+    return &hash->Entries[BKDRHash16bit(NUID)];
 }
 
 unsigned char hsh256DoHashSTR(char *buckle){
@@ -1100,7 +1097,7 @@ void *memAcquireHyper(int Size){
     laMemNodeHyper *mpn = memAcquire_(Size, 2);
     void* mem = ((char*)mpn)+sizeof(laMemNodeHyper);
     memMakeHyperData(mpn);
-    laListHandle* l=hsh16MDoHashNUID(&MAIN.DBInst2,mpn->NUID.String);
+    laListHandle* l=hsh65536DoHashNUID(&MAIN.DBInst2,mpn->NUID.String);
     lstAppendItem(l,mpn);
     return mem;
 }
@@ -1109,7 +1106,7 @@ void memFree(void *Data){
     int level; void* head = memGetHead(Data, &level);
     laMemoryPoolPart *mp;
     if(level==2) { mp = ((laMemNodeHyper*)head)->InPool; laDataBlockNoLongerExists(Data,&((laMemNodeHyper*)head)->Users);
-        laListHandle* l=hsh16MDoHashNUID(&MAIN.DBInst2,((laMemNodeHyper*)head)->NUID.String); lstRemoveItem(l,head);}
+        laListHandle* l=hsh65536DoHashNUID(&MAIN.DBInst2,((laMemNodeHyper*)head)->NUID.String); lstRemoveItem(l,head);}
     if(level==1) { mp = ((laMemNode*)head)->InPool; laDataBlockNoLongerExists(Data,&((laMemNode*)head)->Users); }
     if(level==0) { mp = ((laMemNode0*)head)->InPool; }
     laMemoryPool *mph = mp->PoolRoot;

la_util.h

@@ -232,12 +232,6 @@ struct _laHash256 {
 typedef struct _laHash65536 laHash65536;
 struct _laHash65536 {
 	laListHandle Entries[65536];
-	//laHash256 HashHandles[256];
-};
-
-typedef struct _laHash16M laHash16M;
-struct _laHash16M {
-	laListHandle Entries[16777216];
 };
 
 typedef struct _laSafeString laSafeString;
@@ -588,8 +582,6 @@ void hsh65536Init(laHash65536** h);
 void hshFree(laHash65536** h);
 laListHandle* hsh65536DoHashLongPtr(laHash65536* hash, unsigned long long buckle);
 laListHandle* hsh65536DoHashNUID(laHash65536* hash, char * NUID);
-laListHandle* hsh16MDoHashLongPtr(laHash16M* hash, long long buckle);
-laListHandle* hsh16MDoHashNUID(laHash16M* hash, char * NUID);
 
 laListItem* hsh256FindItemSTR(laHash256* hash, laCompareFunc func, char * buckle);
 unsigned char hsh256DoHashSTR(char * buckle);