public GeoDataBaseClientTests()
        {
            var db = new GeoDataBaseClient("./DataBase/geobase.dat");

            db.Init();
            _client = db;
            _header = db.GetHeader();
        }
Example #2
0
        public void Init(int parallelism)
        {
            using (FileStream stream = File.Open(_pathToFile, FileMode.Open, FileAccess.Read, FileShare.Read))
            {
                Span <byte> buffer = stackalloc byte[Marshal.SizeOf <GeoBaseHeader>()];

                stream.Read(buffer);
                Header = MemoryMarshal.Cast <byte, GeoBaseHeader>(buffer)[0];
            }

            LocationsDatPosSortByCity = new uint[Header.RecordsCount];
            LocationsSortByCityDict   = new Dictionary <uint, int>(LocationsDatPosSortByCity.Length);
            Locations = new Location[Header.RecordsCount];
            IPRanges  = new IPRange[Header.RecordsCount];

            var tasks = new Task[parallelism];

            // load LocationsDatPosSortByCity first, because they give information about Locations collection sorting
            for (int i = 0; i < parallelism; i++)
            {
                int iteration = i;

                var loadIndexesTask = Task.Run(() => Load(
                                                   iteration,
                                                   parallelism,
                                                   Header.OffsetCities,
                                                   LocationsDatPosSortByCity,
                                                   GetIndex
                                                   ));
                tasks[i] = loadIndexesTask;
            }
            Task.WaitAll(tasks);

            for (int i = 0; i < LocationsDatPosSortByCity.Length; i++)
            {
                LocationsSortByCityDict.Add(LocationsDatPosSortByCity[i], i);
            }

            // load rest data
            tasks = new Task[parallelism * 2];
            for (int i = 0; i < parallelism; i++)
            {
                int iteration = i;

                var loadIpRangesTask = Task.Run(() => Load(
                                                    iteration,
                                                    parallelism,
                                                    Header.OffsetRanges,
                                                    IPRanges,
                                                    GetIndex
                                                    ));
                tasks[i * 2] = loadIpRangesTask;

                var loadLocationsTask = Task.Run(() => Load(
                                                     iteration,
                                                     parallelism,
                                                     Header.OffsetLocations,
                                                     Locations,
                                                     GetLocationIndex
                                                     ));
                tasks[i * 2 + 1] = loadLocationsTask;
            }

            Task.WaitAll(tasks);
        }