checkpointmain

2 files changed, 111 insertions, 175 deletions

diff --git a/src/haversine_generator/haversine_generator.cpp b/src/haversine_generator/haversine_generator.cpp
index e0bc37a..3ce2f11 100644
--- a/src/haversine_generator/haversine_generator.cpp
+++ b/src/haversine_generator/haversine_generator.cpp
@@ -21,23 +21,27 @@ POP_WARNINGS
 //~ Macro's
 #define MemoryCopy memcpy
 
-
-//~ Constants
-#define ClusterCount 64
-// NOTE(luca): A double's mantissa is 52 bits.  2^52 - 1 is 4503599627370495 which has 
-// 16 digits.
-#define PointJsonFormat "{ \"x0\": %.15f, \"y0\": %.15f, \"x1\": %.15f, \"y1\": %.15f }\n"
-
 //~ Types
 #include "generated/types.h"
 
-struct cluster
+//~ Helpers
+
+void WriteMemoryTofile(umm Size, void *Memory, umm PairCount, char *Name, char *Extension)
 {
-    f64 X;
-    f64 Y;
-    f64 Width;
-    f64 Height;
-};
+    char FileName[256] = {};
+    stbsp_sprintf(FileName, "data_%lu_%s.%s", PairCount, Name, Extension);
+    
+    int File = open(FileName, O_RDWR|O_CREAT|O_TRUNC, 0600);
+    if(File != -1)
+    {
+        smm BytesWritten = write(File, Memory, Size);
+        Assert(BytesWritten == Size);
+    }
+    else
+    {
+        
+    }
+}
 
 //~ Main
 int main(int ArgsCount, char *Args[], char *Env[])
@@ -49,52 +53,35 @@ int main(int ArgsCount, char *Args[], char *Env[])
         u32 Method = 0;
         u64 RandomSeed = 0;;
         u64 PairCount = 0;
-        b32 Error = false;
         
-        char *MethodString = Args[1];
+        char *MethodName = Args[1];
         char *SeedString = Args[2];
-        char *PairCountString = Args[3];
         
-        if(!strcmp(MethodString, "uniform"))
-        {
-            Method = Method_Uniform;
-        }
-        else if(!strcmp(MethodString, "cluster"))
-        {
-            Method = Method_Cluster;
-        }
-        else
-        {
-            Error = true;
-        }
+        u64 ClusterCountLeft = U64Max;
         
-        RandomSeed = atoll(SeedString);
+        f64 MaxAllowedX = 180.0;
+        f64 MaxAllowedY = 90.0;
+        f64 XCenter = 0.0;
+        f64 YCenter = 0.0;
+        f64 XRadius = MaxAllowedX;
+        f64 YRadius = MaxAllowedY;
         
-        if(RandomSeed == 0)
+        if(!strcmp(MethodName, "cluster"))
         {
-            if(SeedString[0] == '0')
-            {
-                RandomSeed = 0;
-            }
-            else
-            {
-                Error = true;
-            }
+            ClusterCountLeft = 0;
         }
-        
-        PairCount = atoll(PairCountString);
-        if(PairCount == 0)
+        else if(strcmp(MethodName, "uniform"))
         {
-            Error = true;
+            MethodName = "uniform";
+            printf("Warning: Unknown method '%s', uniform used.\n", MethodName);
         }
         
-        if(!Error)
+        RandomSeed = atoll(Args[2]);
+        PairCount = atoll(Args[3]);
+        
+        u64 MaxPairCount = (1LL << 34);
+        if(PairCount < MaxPairCount)
         {
-            printf("Method: %s\n"
-                   "Random seed: %lu\n"
-                   "Pairs count: %lu\n"
-                   , MethodString, RandomSeed, PairCount);
-            
             umm JsonMemorySize = Gigabytes(4);
             u8 *JsonMemory = (u8 *)mmap(0, JsonMemorySize, PROT_READ|PROT_WRITE, MAP_ANONYMOUS|MAP_SHARED, -1, 0);
             u8 *JsonOut = JsonMemory;
@@ -103,141 +90,69 @@ int main(int ArgsCount, char *Args[], char *Env[])
             u8 *BinMemory = (u8 *)mmap(0, BinMemorySize, PROT_READ|PROT_WRITE, MAP_ANONYMOUS|MAP_SHARED, -1, 0);
             u8 *BinOut = BinMemory;
             
-            // Generate pairs in the following format.
-            // 
-            // {
-            //  "pairs": 
-            //   [
-            //    { "x0": ..., "y0": ..., "x1": ..., "y1": ... },
-            //    { "x0": ..., "y0": ..., "x1": ..., "y1": ... }
-            //   ]
-            // }
-            // 
+            JsonOut += stbsp_sprintf((char *)JsonOut, 
+                                     "{\n"
+                                     " \"pairs\":\n"
+                                     "  [\n");
             
-            char *JsonHeader = 
-                "{\n"
-                " \"pairs\":\n"
-                "   [\n";
-            char *JsonFooter =
-                "   ]\n"
-                "}\n";
+            pcg64_random_t Series = {};
+            pcg64_srandom_r(&Series, RandomSeed, RandomSeed);
             
-            JsonOut += stbsp_sprintf((char *)JsonOut, "%s", JsonHeader);
+            u64 ClusterCountMax = 1 + (PairCount / 64);
             
-            pcg64_random_t RNG = {};
-            pcg64_srandom_r(&RNG, RandomSeed, RandomSeed);
+            f64 SumCoefficient = 1.0/(f64)PairCount;
+            f64 Sum = 0;
             
-            if(0) {}
-            else if(Method == Method_Uniform)
+            for(u32 PairIndex = 0;
+                PairIndex < PairCount;
+                PairIndex += 1)
             {
-                f64 AverageSum = 0;
-                f64 TotalSum = 0;
-                for(u64 PairsIndex = 0;
-                    PairsIndex < PairCount;
-                    PairsIndex += 1)
+                if(ClusterCountLeft-- == 0)
                 {
-                    f64 X0 = RandomBetween(&RNG, -180.0, 180.0);
-                    f64 Y0 = RandomBetween(&RNG, -90.0, 90.0);
-                    f64 X1 = RandomBetween(&RNG, -180.0, 180.0); 
-                    f64 Y1 = RandomBetween(&RNG, -90.0, 360.0);
-                    
-                    f64 Sum = ReferenceHaversine(X0, Y0, X1, Y1, 6372.8);
-                    TotalSum += Sum;
-                    
-                    *(f64 *)BinOut = Sum;
-                    BinOut += sizeof(Sum);
+                    ClusterCountLeft = ClusterCountMax;
                     
-                    JsonOut += stbsp_sprintf((char *)JsonOut, "    " PointJsonFormat, X0, Y0, X1, Y1);
+                    XCenter = RandomBetween(&Series, -MaxAllowedX, MaxAllowedX);
+                    YCenter = RandomBetween(&Series, -MaxAllowedY, MaxAllowedY);
+                    XRadius = RandomBetween(&Series, 0, MaxAllowedX);
+                    YRadius = RandomBetween(&Series, 0, MaxAllowedY);
                 }
-                AverageSum = TotalSum / (f64)PairCount;
                 
-                *(f64 *)BinOut = AverageSum;
-                BinOut += sizeof(AverageSum);
+                f64 X0 = RandomDegree(&Series, XCenter, XRadius, MaxAllowedX);
+                f64 Y0 = RandomDegree(&Series, YCenter, YRadius, MaxAllowedY);
+                f64 X1 = RandomDegree(&Series, XCenter, XRadius, MaxAllowedX);
+                f64 Y1 = RandomDegree(&Series, YCenter, YRadius, MaxAllowedY);
                 
-                printf("Average sum: %f\n", AverageSum);
-            }
-            else if(Method == Method_Cluster)
-            {
-                cluster Clusters[ClusterCount] = {};
-                for(u32 ClusterIndex = 0;
-                    ClusterIndex < ClusterCount;
-                    ClusterIndex += 1)
-                {
-                    cluster *ClusterAt = Clusters + ClusterIndex;
-                    ClusterAt->X = RandomBetween(&RNG, -180.0, 180.0);
-                    ClusterAt->Y = RandomBetween(&RNG, -90.0, 90.0);
-                    ClusterAt->Width = RandomBetween(&RNG, 0.0, 180.0);
-                    ClusterAt->Height = RandomBetween(&RNG, 0.0, 90.0);
-                }
-                
-                f64 AverageSum = 0;
-                f64 TotalSum = 0;
-                u32 ClusterIndex = 0;
-                for(u32 PairIndex = 0;
-                    PairIndex < PairCount;
-                    PairIndex += 1)
-                {
-                    cluster *ClusterAt = Clusters + ClusterIndex;
-                    
-                    f64 X0 = RandomBetween(&RNG, ClusterAt->X - ClusterAt->Width, ClusterAt->X + ClusterAt->Width);
-                    f64 Y0 = RandomBetween(&RNG, ClusterAt->Y - ClusterAt->Height, ClusterAt->Y + ClusterAt->Height);
-                    f64 X1 = RandomBetween(&RNG, ClusterAt->X - ClusterAt->Width, ClusterAt->X + ClusterAt->Width);
-                    f64 Y1 = RandomBetween(&RNG, ClusterAt->Y - ClusterAt->Height, ClusterAt->Y + ClusterAt->Height);
-                    
-                    f64 Sum = ReferenceHaversine(X0, Y0, X1, Y1, 6372.8);
-                    TotalSum += Sum;
-                    
-                    *(f64 *)BinOut = Sum;
-                    BinOut += sizeof(Sum);
-                    
-                    JsonOut += stbsp_sprintf((char *)JsonOut, "    " PointJsonFormat, X0, Y0, X1, Y1);
-                    
-                    ClusterIndex += 1;
-                    if(ClusterIndex == ClusterCount)
-                    {
-                        ClusterIndex -= ClusterCount;
-                    }
-                    
-                }
-                AverageSum = TotalSum / (f64)PairCount;
+                f64 EarthRadius = 6372.8;
+                f64 Distance = ReferenceHaversine(X0, Y0, X1, Y1, EarthRadius);
+                Sum += SumCoefficient*Distance;
                 
-                *(f64 *)BinOut = AverageSum;
-                BinOut += sizeof(AverageSum);
+                *(f64 *)BinOut = Distance;
+                BinOut += sizeof(Distance);
                 
-                printf("Average sum: %f\n", AverageSum);
-            }
-            else
-            {
-                Assert(0);
+                const char *Separator = (PairIndex == PairCount - 1) ? "\n" : ",\n";
+                JsonOut += stbsp_sprintf((char *)JsonOut, 
+                                         "   { \"x0\": %.16f, \"y0\": %.16f, \"x1\": %.16f, \"y1\": %.16f }%s", 
+                                         X0, Y0, X1, Y1, Separator);
             }
             
-            JsonOut += stbsp_sprintf((char *)JsonOut, "%s", JsonFooter);
+            *(f64 *)BinOut = Sum;
+            BinOut += sizeof(Sum);
             
-            // Write memory to json file
-            {            
-                char JsonFileName[256] = {};
-                stbsp_sprintf(JsonFileName, "data_%lu.json", PairCount);
-                
-                int File = open(JsonFileName, O_RDWR|O_CREAT|O_TRUNC, 0600);
-                Assert(File != -1);
-                smm Result = write(File, JsonMemory, JsonOut - JsonMemory);
-                Assert(Result == JsonOut - JsonMemory);
-            }
+            printf("Method: %s\n"
+                   "Random seed: %lu\n"
+                   "Pairs count: %lu\n"
+                   , MethodName, RandomSeed, PairCount);
+            printf("Average sum: %.16f\n", Sum);
             
-            // Write memory to binary answer file
-            char BinFileName[256] = {};
-            {
-                stbsp_sprintf(BinFileName, "data_%lu_haveranswer.f64", PairCount);
-                int File = open(BinFileName, O_RDWR|O_CREAT|O_TRUNC, 0600);
-                Assert(File != -1);
-                smm Result = write(File, BinMemory, BinOut - BinMemory);
-                Assert(Result == BinOut - BinMemory);
-            }
+            JsonOut += stbsp_sprintf((char *)JsonOut, 
+                                     "  ]\n"
+                                     "}\n");
+            WriteMemoryTofile(JsonOut - JsonMemory, JsonMemory, PairCount, "flex", "json");
+            WriteMemoryTofile(BinOut - BinMemory, BinMemory, PairCount, "haveranswer", "f64");
         }
         else
         {
-            printf("Usage: %s [uniform/cluster] [random seed] [number of pairs to generate]\n", 
-                   Args[0]);
+            printf("Massive files unsupported. Number of pairs must be less than %lu.\n", MaxPairCount);
         }
     }
     else
diff --git a/src/haversine_generator/haversine_random.h b/src/haversine_generator/haversine_random.h
index e80df7d..76d766e 100644
--- a/src/haversine_generator/haversine_random.h
+++ b/src/haversine_generator/haversine_random.h
@@ -5,10 +5,12 @@ POP_WARNINGS
 
 #define CountLeadingZeroes64(Value)	__builtin_clzll(Value)
 
+typedef pcg64_random_t random_series;
+
 u64 
-RandomU64(pcg64_random_t *RNG)
+RandomU64(random_series *Series)
 {
-    u64 Result = pcg64_random_r(RNG);
+    u64 Result = pcg64_random_r(Series);
     return Result;
 }
 
@@ -30,7 +32,7 @@ RandomU64(pcg64_random_t *RNG)
  * number in [0, 1], 0.00001010011111010100...; then round it.
  */
 f64
-RandomF64(pcg64_random_t *RNG)
+RandomF64(random_series *Series)
 {
 	s32 Exponent = -64;
 	u64 Significand;
@@ -40,7 +42,7 @@ RandomF64(pcg64_random_t *RNG)
 	 * Read zeros into the exponent until we hit a one; the rest
 	 * will go into the significand.
 	 */
-	while((Significand = RandomU64(RNG)) == 0) 
+	while((Significand = RandomU64(Series)) == 0) 
     {
 		Exponent -= 64;
 		/*
@@ -66,7 +68,7 @@ RandomF64(pcg64_random_t *RNG)
 	if (Shift != 0) {
 		Exponent -= Shift;
 		Significand <<= Shift;
-		Significand |= (RandomU64(RNG) >> (64 - Shift));
+		Significand |= (RandomU64(Series) >> (64 - Shift));
 	}
     
 	/*
@@ -86,22 +88,41 @@ RandomF64(pcg64_random_t *RNG)
 }
 
 f64
-RandomUnilateral(pcg64_random_t *RNG)
+RandomUnilateral(random_series *Series)
 {
-    return RandomF64(RNG);
+    return RandomF64(Series);
 }
 
 f64
-RandomBilateral(pcg64_random_t *RNG)
+RandomBilateral(random_series *Series)
 {
-    f64 Result = 2.0*RandomUnilateral(RNG) - 1.0;
+    f64 Result = 2.0*RandomUnilateral(Series) - 1.0;
     return Result;
 }
 
 f64
-RandomBetween(pcg64_random_t *RNG, f64 Min, f64 Max)
+RandomBetween(random_series *Series, f64 Min, f64 Max)
 {
     f64 Range = Max - Min;
-    f64 Result = Min + RandomUnilateral(RNG)*Range;
+    f64 Result = Min + RandomUnilateral(Series)*Range;
+    return Result;
+}
+
+
+static f64 RandomDegree(random_series *Series, f64 Center, f64 Radius, f64 MaxAllowed)
+{
+    f64 MinVal = Center - Radius;
+    if(MinVal < -MaxAllowed)
+    {
+        MinVal = -MaxAllowed;
+    }
+    
+    f64 MaxVal = Center + Radius;
+    if(MaxVal > MaxAllowed)
+    {
+        MaxVal = MaxAllowed;
+    }
+    
+    f64 Result = RandomBetween(Series, MinVal, MaxVal);
     return Result;
 }
\ No newline at end of file