From 04bd2d69b61a38a077bcd7d198648d2b450827be Mon Sep 17 00:00:00 2001 From: Rene Schwietzke Date: Wed, 3 Jan 2024 00:13:11 +0100 Subject: [PATCH] Faster version of the data generator --- create_measurements2.sh | 19 + .../onebrc/CalculateAverage_royvanrijn.java | 4 +- .../morling/onebrc/CreateMeasurements2.java | 623 +++++++++++++++ .../org/rschwietzke/CheaperCharBuffer.java | 715 ++++++++++++++++++ src/main/java/org/rschwietzke/FastRandom.java | 76 ++ 5 files changed, 1435 insertions(+), 2 deletions(-) create mode 100755 create_measurements2.sh create mode 100644 src/main/java/dev/morling/onebrc/CreateMeasurements2.java create mode 100644 src/main/java/org/rschwietzke/CheaperCharBuffer.java create mode 100644 src/main/java/org/rschwietzke/FastRandom.java diff --git a/create_measurements2.sh b/create_measurements2.sh new file mode 100755 index 0000000..d262e44 --- /dev/null +++ b/create_measurements2.sh @@ -0,0 +1,19 @@ +#!/bin/sh +# +# Copyright 2023 The original authors +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + + +java --class-path target/average-1.0.0-SNAPSHOT.jar dev.morling.onebrc.CreateMeasurements2 $1 diff --git a/src/main/java/dev/morling/onebrc/CalculateAverage_royvanrijn.java b/src/main/java/dev/morling/onebrc/CalculateAverage_royvanrijn.java index e9d1e19..baf9cba 100644 --- a/src/main/java/dev/morling/onebrc/CalculateAverage_royvanrijn.java +++ b/src/main/java/dev/morling/onebrc/CalculateAverage_royvanrijn.java @@ -52,7 +52,7 @@ public class CalculateAverage_royvanrijn { public static void main(String[] args) throws IOException { -// long before = System.currentTimeMillis(); + // long before = System.currentTimeMillis(); Map resultMap = Files.lines(Path.of(FILE)).parallel() .map(record -> { @@ -73,7 +73,7 @@ public class CalculateAverage_royvanrijn { resultMap.entrySet().stream().sorted(Map.Entry.comparingByKey()).map(Object::toString).collect(Collectors.joining(", "))); System.out.println("}"); -// System.out.println("Took: " + (System.currentTimeMillis() - before)); + // System.out.println("Took: " + (System.currentTimeMillis() - before)); } } diff --git a/src/main/java/dev/morling/onebrc/CreateMeasurements2.java b/src/main/java/dev/morling/onebrc/CreateMeasurements2.java new file mode 100644 index 0000000..4eedfea --- /dev/null +++ b/src/main/java/dev/morling/onebrc/CreateMeasurements2.java @@ -0,0 +1,623 @@ +/* + * Copyright 2023 The original authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package dev.morling.onebrc; + +import java.io.BufferedWriter; +import java.io.File; +import java.io.FileWriter; +import java.io.IOException; +import java.util.Arrays; +import java.util.List; +import java.util.concurrent.ThreadLocalRandom; + +import org.rschwietzke.CheaperCharBuffer; +import org.rschwietzke.FastRandom; + +/** + * Faster version with some data faking instead of a real Gaussian distribution + * Good enough for our purppose I guess. + */ +public class CreateMeasurements2 { + + private static final String FILE = "./measurements2.txt"; + + static class WeatherStation { + final static char[] NUMBERS = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9' }; + + final String id; + final int meanTemperature; + + final char[] firstPart; + final FastRandom r = new FastRandom(ThreadLocalRandom.current().nextLong()); + + WeatherStation(String id, double meanTemperature) { + this.id = id; + this.meanTemperature = (int) meanTemperature; + // make it directly copyable + this.firstPart = (id + ";").toCharArray(); + } + + /** + * We write out data into the buffer to avoid string conversion + * We also no longer use double and gaussian, because for our + * purpose, the fake numbers here will do it. Less + * + * @param buffer the buffer to append to + */ + void measurement(final CheaperCharBuffer buffer) { + // fake -10.9 to +10.9 variance without double operations and rounding + // gives us -10 to +10 + int m = meanTemperature + (r.nextInt(21) - 10); + // gives us a decimal digit 0 to 9 as char + char d = NUMBERS[r.nextInt(10)]; + + // just append, only one number has to be converted and we can do + // better... if we watn + buffer.append(firstPart, 0, firstPart.length) + .append(String.valueOf(m)).append('.').append(d) + .append('\n'); + } + } + + public static void main(String[] args) throws Exception { + long start = System.currentTimeMillis(); + + if (args.length != 1) { + System.out.println("Usage: create_measurements.sh "); + System.exit(1); + } + + int size = 0; + try { + size = Integer.parseInt(args[0]); + } + catch (NumberFormatException e) { + System.out.println("Invalid value for "); + System.out.println("Usage: CreateMeasurements "); + System.exit(1); + } + + // @formatter:off + // data from https://en.wikipedia.org/wiki/List_of_cities_by_average_temperature; + // converted using https://wikitable2csv.ggor.de/ + // brought to form using DuckDB: + // D copy ( + // select City, regexp_extract(Year,'(.*)\n.*', 1) as AverageTemp + // from ( + // select City,Year + // from read_csv_auto('List_of_cities_by_average_temperature_1.csv', header = true) + // union + // select City,Year + // from read_csv_auto('List_of_cities_by_average_temperature_2.csv', header = true) + // union + // select City,Year + // from read_csv_auto('List_of_cities_by_average_temperature_3.csv', header = true) + // union + // select City,Year + // from read_csv_auto('List_of_cities_by_average_temperature_4.csv', header = true) + // union + // select City,Year + // from read_csv_auto('List_of_cities_by_average_temperature_5.csv', header = true) + // ) + // ) TO 'output.csv' (HEADER, DELIMITER ','); + // @formatter:on + final List stations = Arrays.asList( + new WeatherStation("Abha", 18.0), + new WeatherStation("Abidjan", 26.0), + new WeatherStation("Abéché", 29.4), + new WeatherStation("Accra", 26.4), + new WeatherStation("Addis Ababa", 16.0), + new WeatherStation("Adelaide", 17.3), + new WeatherStation("Aden", 29.1), + new WeatherStation("Ahvaz", 25.4), + new WeatherStation("Albuquerque", 14.0), + new WeatherStation("Alexandra", 11.0), + new WeatherStation("Alexandria", 20.0), + new WeatherStation("Algiers", 18.2), + new WeatherStation("Alice Springs", 21.0), + new WeatherStation("Almaty", 10.0), + new WeatherStation("Amsterdam", 10.2), + new WeatherStation("Anadyr", -6.9), + new WeatherStation("Anchorage", 2.8), + new WeatherStation("Andorra la Vella", 9.8), + new WeatherStation("Ankara", 12.0), + new WeatherStation("Antananarivo", 17.9), + new WeatherStation("Antsiranana", 25.2), + new WeatherStation("Arkhangelsk", 1.3), + new WeatherStation("Ashgabat", 17.1), + new WeatherStation("Asmara", 15.6), + new WeatherStation("Assab", 30.5), + new WeatherStation("Astana", 3.5), + new WeatherStation("Athens", 19.2), + new WeatherStation("Atlanta", 17.0), + new WeatherStation("Auckland", 15.2), + new WeatherStation("Austin", 20.7), + new WeatherStation("Baghdad", 22.77), + new WeatherStation("Baguio", 19.5), + new WeatherStation("Baku", 15.1), + new WeatherStation("Baltimore", 13.1), + new WeatherStation("Bamako", 27.8), + new WeatherStation("Bangkok", 28.6), + new WeatherStation("Bangui", 26.0), + new WeatherStation("Banjul", 26.0), + new WeatherStation("Barcelona", 18.2), + new WeatherStation("Bata", 25.1), + new WeatherStation("Batumi", 14.0), + new WeatherStation("Beijing", 12.9), + new WeatherStation("Beirut", 20.9), + new WeatherStation("Belgrade", 12.5), + new WeatherStation("Belize City", 26.7), + new WeatherStation("Benghazi", 19.9), + new WeatherStation("Bergen", 7.7), + new WeatherStation("Berlin", 10.3), + new WeatherStation("Bilbao", 14.7), + new WeatherStation("Birao", 26.5), + new WeatherStation("Bishkek", 11.3), + new WeatherStation("Bissau", 27.0), + new WeatherStation("Blantyre", 22.2), + new WeatherStation("Bloemfontein", 15.6), + new WeatherStation("Boise", 11.4), + new WeatherStation("Bordeaux", 14.2), + new WeatherStation("Bosaso", 30.0), + new WeatherStation("Boston", 10.9), + new WeatherStation("Bouaké", 26.0), + new WeatherStation("Bratislava", 10.5), + new WeatherStation("Brazzaville", 25.0), + new WeatherStation("Bridgetown", 27.0), + new WeatherStation("Brisbane", 21.4), + new WeatherStation("Brussels", 10.5), + new WeatherStation("Bucharest", 10.8), + new WeatherStation("Budapest", 11.3), + new WeatherStation("Bujumbura", 23.8), + new WeatherStation("Bulawayo", 18.9), + new WeatherStation("Burnie", 13.1), + new WeatherStation("Busan", 15.0), + new WeatherStation("Cabo San Lucas", 23.9), + new WeatherStation("Cairns", 25.0), + new WeatherStation("Cairo", 21.4), + new WeatherStation("Calgary", 4.4), + new WeatherStation("Canberra", 13.1), + new WeatherStation("Cape Town", 16.2), + new WeatherStation("Changsha", 17.4), + new WeatherStation("Charlotte", 16.1), + new WeatherStation("Chiang Mai", 25.8), + new WeatherStation("Chicago", 9.8), + new WeatherStation("Chihuahua", 18.6), + new WeatherStation("Chișinău", 10.2), + new WeatherStation("Chittagong", 25.9), + new WeatherStation("Chongqing", 18.6), + new WeatherStation("Christchurch", 12.2), + new WeatherStation("City of San Marino", 11.8), + new WeatherStation("Colombo", 27.4), + new WeatherStation("Columbus", 11.7), + new WeatherStation("Conakry", 26.4), + new WeatherStation("Copenhagen", 9.1), + new WeatherStation("Cotonou", 27.2), + new WeatherStation("Cracow", 9.3), + new WeatherStation("Da Lat", 17.9), + new WeatherStation("Da Nang", 25.8), + new WeatherStation("Dakar", 24.0), + new WeatherStation("Dallas", 19.0), + new WeatherStation("Damascus", 17.0), + new WeatherStation("Dampier", 26.4), + new WeatherStation("Dar es Salaam", 25.8), + new WeatherStation("Darwin", 27.6), + new WeatherStation("Denpasar", 23.7), + new WeatherStation("Denver", 10.4), + new WeatherStation("Detroit", 10.0), + new WeatherStation("Dhaka", 25.9), + new WeatherStation("Dikson", -11.1), + new WeatherStation("Dili", 26.6), + new WeatherStation("Djibouti", 29.9), + new WeatherStation("Dodoma", 22.7), + new WeatherStation("Dolisie", 24.0), + new WeatherStation("Douala", 26.7), + new WeatherStation("Dubai", 26.9), + new WeatherStation("Dublin", 9.8), + new WeatherStation("Dunedin", 11.1), + new WeatherStation("Durban", 20.6), + new WeatherStation("Dushanbe", 14.7), + new WeatherStation("Edinburgh", 9.3), + new WeatherStation("Edmonton", 4.2), + new WeatherStation("El Paso", 18.1), + new WeatherStation("Entebbe", 21.0), + new WeatherStation("Erbil", 19.5), + new WeatherStation("Erzurum", 5.1), + new WeatherStation("Fairbanks", -2.3), + new WeatherStation("Fianarantsoa", 17.9), + new WeatherStation("Flores, Petén", 26.4), + new WeatherStation("Frankfurt", 10.6), + new WeatherStation("Fresno", 17.9), + new WeatherStation("Fukuoka", 17.0), + new WeatherStation("Gabès", 19.5), + new WeatherStation("Gaborone", 21.0), + new WeatherStation("Gagnoa", 26.0), + new WeatherStation("Gangtok", 15.2), + new WeatherStation("Garissa", 29.3), + new WeatherStation("Garoua", 28.3), + new WeatherStation("George Town", 27.9), + new WeatherStation("Ghanzi", 21.4), + new WeatherStation("Gjoa Haven", -14.4), + new WeatherStation("Guadalajara", 20.9), + new WeatherStation("Guangzhou", 22.4), + new WeatherStation("Guatemala City", 20.4), + new WeatherStation("Halifax", 7.5), + new WeatherStation("Hamburg", 9.7), + new WeatherStation("Hamilton", 13.8), + new WeatherStation("Hanga Roa", 20.5), + new WeatherStation("Hanoi", 23.6), + new WeatherStation("Harare", 18.4), + new WeatherStation("Harbin", 5.0), + new WeatherStation("Hargeisa", 21.7), + new WeatherStation("Hat Yai", 27.0), + new WeatherStation("Havana", 25.2), + new WeatherStation("Helsinki", 5.9), + new WeatherStation("Heraklion", 18.9), + new WeatherStation("Hiroshima", 16.3), + new WeatherStation("Ho Chi Minh City", 27.4), + new WeatherStation("Hobart", 12.7), + new WeatherStation("Hong Kong", 23.3), + new WeatherStation("Honiara", 26.5), + new WeatherStation("Honolulu", 25.4), + new WeatherStation("Houston", 20.8), + new WeatherStation("Ifrane", 11.4), + new WeatherStation("Indianapolis", 11.8), + new WeatherStation("Iqaluit", -9.3), + new WeatherStation("Irkutsk", 1.0), + new WeatherStation("Istanbul", 13.9), + new WeatherStation("İzmir", 17.9), + new WeatherStation("Jacksonville", 20.3), + new WeatherStation("Jakarta", 26.7), + new WeatherStation("Jayapura", 27.0), + new WeatherStation("Jerusalem", 18.3), + new WeatherStation("Johannesburg", 15.5), + new WeatherStation("Jos", 22.8), + new WeatherStation("Juba", 27.8), + new WeatherStation("Kabul", 12.1), + new WeatherStation("Kampala", 20.0), + new WeatherStation("Kandi", 27.7), + new WeatherStation("Kankan", 26.5), + new WeatherStation("Kano", 26.4), + new WeatherStation("Kansas City", 12.5), + new WeatherStation("Karachi", 26.0), + new WeatherStation("Karonga", 24.4), + new WeatherStation("Kathmandu", 18.3), + new WeatherStation("Khartoum", 29.9), + new WeatherStation("Kingston", 27.4), + new WeatherStation("Kinshasa", 25.3), + new WeatherStation("Kolkata", 26.7), + new WeatherStation("Kuala Lumpur", 27.3), + new WeatherStation("Kumasi", 26.0), + new WeatherStation("Kunming", 15.7), + new WeatherStation("Kuopio", 3.4), + new WeatherStation("Kuwait City", 25.7), + new WeatherStation("Kyiv", 8.4), + new WeatherStation("Kyoto", 15.8), + new WeatherStation("La Ceiba", 26.2), + new WeatherStation("La Paz", 23.7), + new WeatherStation("Lagos", 26.8), + new WeatherStation("Lahore", 24.3), + new WeatherStation("Lake Havasu City", 23.7), + new WeatherStation("Lake Tekapo", 8.7), + new WeatherStation("Las Palmas de Gran Canaria", 21.2), + new WeatherStation("Las Vegas", 20.3), + new WeatherStation("Launceston", 13.1), + new WeatherStation("Lhasa", 7.6), + new WeatherStation("Libreville", 25.9), + new WeatherStation("Lisbon", 17.5), + new WeatherStation("Livingstone", 21.8), + new WeatherStation("Ljubljana", 10.9), + new WeatherStation("Lodwar", 29.3), + new WeatherStation("Lomé", 26.9), + new WeatherStation("London", 11.3), + new WeatherStation("Los Angeles", 18.6), + new WeatherStation("Louisville", 13.9), + new WeatherStation("Luanda", 25.8), + new WeatherStation("Lubumbashi", 20.8), + new WeatherStation("Lusaka", 19.9), + new WeatherStation("Luxembourg City", 9.3), + new WeatherStation("Lviv", 7.8), + new WeatherStation("Lyon", 12.5), + new WeatherStation("Madrid", 15.0), + new WeatherStation("Mahajanga", 26.3), + new WeatherStation("Makassar", 26.7), + new WeatherStation("Makurdi", 26.0), + new WeatherStation("Malabo", 26.3), + new WeatherStation("Malé", 28.0), + new WeatherStation("Managua", 27.3), + new WeatherStation("Manama", 26.5), + new WeatherStation("Mandalay", 28.0), + new WeatherStation("Mango", 28.1), + new WeatherStation("Manila", 28.4), + new WeatherStation("Maputo", 22.8), + new WeatherStation("Marrakesh", 19.6), + new WeatherStation("Marseille", 15.8), + new WeatherStation("Maun", 22.4), + new WeatherStation("Medan", 26.5), + new WeatherStation("Mek'ele", 22.7), + new WeatherStation("Melbourne", 15.1), + new WeatherStation("Memphis", 17.2), + new WeatherStation("Mexicali", 23.1), + new WeatherStation("Mexico City", 17.5), + new WeatherStation("Miami", 24.9), + new WeatherStation("Milan", 13.0), + new WeatherStation("Milwaukee", 8.9), + new WeatherStation("Minneapolis", 7.8), + new WeatherStation("Minsk", 6.7), + new WeatherStation("Mogadishu", 27.1), + new WeatherStation("Mombasa", 26.3), + new WeatherStation("Monaco", 16.4), + new WeatherStation("Moncton", 6.1), + new WeatherStation("Monterrey", 22.3), + new WeatherStation("Montreal", 6.8), + new WeatherStation("Moscow", 5.8), + new WeatherStation("Mumbai", 27.1), + new WeatherStation("Murmansk", 0.6), + new WeatherStation("Muscat", 28.0), + new WeatherStation("Mzuzu", 17.7), + new WeatherStation("N'Djamena", 28.3), + new WeatherStation("Naha", 23.1), + new WeatherStation("Nairobi", 17.8), + new WeatherStation("Nakhon Ratchasima", 27.3), + new WeatherStation("Napier", 14.6), + new WeatherStation("Napoli", 15.9), + new WeatherStation("Nashville", 15.4), + new WeatherStation("Nassau", 24.6), + new WeatherStation("Ndola", 20.3), + new WeatherStation("New Delhi", 25.0), + new WeatherStation("New Orleans", 20.7), + new WeatherStation("New York City", 12.9), + new WeatherStation("Ngaoundéré", 22.0), + new WeatherStation("Niamey", 29.3), + new WeatherStation("Nicosia", 19.7), + new WeatherStation("Niigata", 13.9), + new WeatherStation("Nouadhibou", 21.3), + new WeatherStation("Nouakchott", 25.7), + new WeatherStation("Novosibirsk", 1.7), + new WeatherStation("Nuuk", -1.4), + new WeatherStation("Odesa", 10.7), + new WeatherStation("Odienné", 26.0), + new WeatherStation("Oklahoma City", 15.9), + new WeatherStation("Omaha", 10.6), + new WeatherStation("Oranjestad", 28.1), + new WeatherStation("Oslo", 5.7), + new WeatherStation("Ottawa", 6.6), + new WeatherStation("Ouagadougou", 28.3), + new WeatherStation("Ouahigouya", 28.6), + new WeatherStation("Ouarzazate", 18.9), + new WeatherStation("Oulu", 2.7), + new WeatherStation("Palembang", 27.3), + new WeatherStation("Palermo", 18.5), + new WeatherStation("Palm Springs", 24.5), + new WeatherStation("Palmerston North", 13.2), + new WeatherStation("Panama City", 28.0), + new WeatherStation("Parakou", 26.8), + new WeatherStation("Paris", 12.3), + new WeatherStation("Perth", 18.7), + new WeatherStation("Petropavlovsk-Kamchatsky", 1.9), + new WeatherStation("Philadelphia", 13.2), + new WeatherStation("Phnom Penh", 28.3), + new WeatherStation("Phoenix", 23.9), + new WeatherStation("Pittsburgh", 10.8), + new WeatherStation("Podgorica", 15.3), + new WeatherStation("Pointe-Noire", 26.1), + new WeatherStation("Pontianak", 27.7), + new WeatherStation("Port Moresby", 26.9), + new WeatherStation("Port Sudan", 28.4), + new WeatherStation("Port Vila", 24.3), + new WeatherStation("Port-Gentil", 26.0), + new WeatherStation("Portland (OR)", 12.4), + new WeatherStation("Porto", 15.7), + new WeatherStation("Prague", 8.4), + new WeatherStation("Praia", 24.4), + new WeatherStation("Pretoria", 18.2), + new WeatherStation("Pyongyang", 10.8), + new WeatherStation("Rabat", 17.2), + new WeatherStation("Rangpur", 24.4), + new WeatherStation("Reggane", 28.3), + new WeatherStation("Reykjavík", 4.3), + new WeatherStation("Riga", 6.2), + new WeatherStation("Riyadh", 26.0), + new WeatherStation("Rome", 15.2), + new WeatherStation("Roseau", 26.2), + new WeatherStation("Rostov-on-Don", 9.9), + new WeatherStation("Sacramento", 16.3), + new WeatherStation("Saint Petersburg", 5.8), + new WeatherStation("Saint-Pierre", 5.7), + new WeatherStation("Salt Lake City", 11.6), + new WeatherStation("San Antonio", 20.8), + new WeatherStation("San Diego", 17.8), + new WeatherStation("San Francisco", 14.6), + new WeatherStation("San Jose", 16.4), + new WeatherStation("San José", 22.6), + new WeatherStation("San Juan", 27.2), + new WeatherStation("San Salvador", 23.1), + new WeatherStation("Sana'a", 20.0), + new WeatherStation("Santo Domingo", 25.9), + new WeatherStation("Sapporo", 8.9), + new WeatherStation("Sarajevo", 10.1), + new WeatherStation("Saskatoon", 3.3), + new WeatherStation("Seattle", 11.3), + new WeatherStation("Ségou", 28.0), + new WeatherStation("Seoul", 12.5), + new WeatherStation("Seville", 19.2), + new WeatherStation("Shanghai", 16.7), + new WeatherStation("Singapore", 27.0), + new WeatherStation("Skopje", 12.4), + new WeatherStation("Sochi", 14.2), + new WeatherStation("Sofia", 10.6), + new WeatherStation("Sokoto", 28.0), + new WeatherStation("Split", 16.1), + new WeatherStation("St. John's", 5.0), + new WeatherStation("St. Louis", 13.9), + new WeatherStation("Stockholm", 6.6), + new WeatherStation("Surabaya", 27.1), + new WeatherStation("Suva", 25.6), + new WeatherStation("Suwałki", 7.2), + new WeatherStation("Sydney", 17.7), + new WeatherStation("Tabora", 23.0), + new WeatherStation("Tabriz", 12.6), + new WeatherStation("Taipei", 23.0), + new WeatherStation("Tallinn", 6.4), + new WeatherStation("Tamale", 27.9), + new WeatherStation("Tamanrasset", 21.7), + new WeatherStation("Tampa", 22.9), + new WeatherStation("Tashkent", 14.8), + new WeatherStation("Tauranga", 14.8), + new WeatherStation("Tbilisi", 12.9), + new WeatherStation("Tegucigalpa", 21.7), + new WeatherStation("Tehran", 17.0), + new WeatherStation("Tel Aviv", 20.0), + new WeatherStation("Thessaloniki", 16.0), + new WeatherStation("Thiès", 24.0), + new WeatherStation("Tijuana", 17.8), + new WeatherStation("Timbuktu", 28.0), + new WeatherStation("Tirana", 15.2), + new WeatherStation("Toamasina", 23.4), + new WeatherStation("Tokyo", 15.4), + new WeatherStation("Toliara", 24.1), + new WeatherStation("Toluca", 12.4), + new WeatherStation("Toronto", 9.4), + new WeatherStation("Tripoli", 20.0), + new WeatherStation("Tromsø", 2.9), + new WeatherStation("Tucson", 20.9), + new WeatherStation("Tunis", 18.4), + new WeatherStation("Ulaanbaatar", -0.4), + new WeatherStation("Upington", 20.4), + new WeatherStation("Ürümqi", 7.4), + new WeatherStation("Vaduz", 10.1), + new WeatherStation("Valencia", 18.3), + new WeatherStation("Valletta", 18.8), + new WeatherStation("Vancouver", 10.4), + new WeatherStation("Veracruz", 25.4), + new WeatherStation("Vienna", 10.4), + new WeatherStation("Vientiane", 25.9), + new WeatherStation("Villahermosa", 27.1), + new WeatherStation("Vilnius", 6.0), + new WeatherStation("Virginia Beach", 15.8), + new WeatherStation("Vladivostok", 4.9), + new WeatherStation("Warsaw", 8.5), + new WeatherStation("Washington, D.C.", 14.6), + new WeatherStation("Wau", 27.8), + new WeatherStation("Wellington", 12.9), + new WeatherStation("Whitehorse", -0.1), + new WeatherStation("Wichita", 13.9), + new WeatherStation("Willemstad", 28.0), + new WeatherStation("Winnipeg", 3.0), + new WeatherStation("Wrocław", 9.6), + new WeatherStation("Xi'an", 14.1), + new WeatherStation("Yakutsk", -8.8), + new WeatherStation("Yangon", 27.5), + new WeatherStation("Yaoundé", 23.8), + new WeatherStation("Yellowknife", -4.3), + new WeatherStation("Yerevan", 12.4), + new WeatherStation("Yinchuan", 9.0), + new WeatherStation("Zagreb", 10.7), + new WeatherStation("Zanzibar City", 26.0), + new WeatherStation("Zürich", 9.3)); + + File file = new File(FILE); + + // break the loop and unroll it manually + int strideSize = 50_000_000; + int outer = size / strideSize; + int remainder = size - (outer * strideSize); + + try (final BufferedWriter bw = new BufferedWriter(new FileWriter(file))) { + for (int i = 0; i < outer; i++) { + produce(bw, stations, strideSize); + + // we avoid a modulo if here and use the stride size to print and update + System.out.println("Wrote %,d measurements in %s ms".formatted((i + 1) * strideSize, System.currentTimeMillis() - start)); + } + // there might be a rest + produce(bw, stations, remainder); + + // write fully before taking measurements + bw.flush(); + System.out.println("Created file with %,d measurements in %s ms".formatted(size, System.currentTimeMillis() - start)); + } + } + + private static void produce(BufferedWriter bw, List stations, int count) throws IOException { + final int stationCount = stations.size(); + final int rest = count % 8; + + // use a fast ranodm impl without atomics to be able to utilize the cpu better + // and avoid sideeffects, FastRandom is very fake random and does not have a state + final FastRandom r1 = new FastRandom(ThreadLocalRandom.current().nextLong()); + final FastRandom r2 = new FastRandom(ThreadLocalRandom.current().nextLong()); + final FastRandom r3 = new FastRandom(ThreadLocalRandom.current().nextLong()); + final FastRandom r4 = new FastRandom(ThreadLocalRandom.current().nextLong()); + + // write to a fix buffer first, don't create strings ever + // reuse buffer + final CheaperCharBuffer sb = new CheaperCharBuffer(200); + + // manual loop unroll for less jumps + for (int i = 0; i < count; i = i + 8) { + { + // try to fill teh cpu pipeline as much as possible with + // independent operations + int s1 = r1.nextInt(stationCount); + int s2 = r2.nextInt(stationCount); + int s3 = r3.nextInt(stationCount); + int s4 = r4.nextInt(stationCount); + // get us the ojects one after the other to have the array + // in our L1 cache and not push it out with other data + var w1 = stations.get(s1); + var w2 = stations.get(s2); + var w3 = stations.get(s3); + var w4 = stations.get(s4); + // write our data to our buffer + w1.measurement(sb); + w2.measurement(sb); + w3.measurement(sb); + w4.measurement(sb); + } + { + int s1 = r1.nextInt(stationCount); + int s2 = r2.nextInt(stationCount); + int s3 = r3.nextInt(stationCount); + int s4 = r4.nextInt(stationCount); + var w1 = stations.get(s1); + var w2 = stations.get(s2); + var w3 = stations.get(s3); + var w4 = stations.get(s4); + w1.measurement(sb); + w2.measurement(sb); + w3.measurement(sb); + w4.measurement(sb); + } + // write the buffer directly, no intermediate string copy + bw.write(sb.data_, 0, sb.length_); + + // reuse buffer, reset only, no cleaning + sb.clear(); + } + + // there might be a rest to write + for (int i = 0; i < rest; i++) { + sb.clear(); + + int s = r1.nextInt(stationCount); + var w = stations.get(s); + w.measurement(sb); + + bw.write(sb.data_, 0, sb.length_); + } + } +} diff --git a/src/main/java/org/rschwietzke/CheaperCharBuffer.java b/src/main/java/org/rschwietzke/CheaperCharBuffer.java new file mode 100644 index 0000000..d2e3d82 --- /dev/null +++ b/src/main/java/org/rschwietzke/CheaperCharBuffer.java @@ -0,0 +1,715 @@ +/* + * Copyright 2023 The original authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.rschwietzke; + +import java.util.Arrays; + +/** + *

This class is meant to replaces the old {@link CheaperCharBuffer} in all areas + * where performance and memory-efficency is key. XMLString compatibility + * remains in place in case one has used that in their own code. + * + *

This buffer is mutable and when you use it, make sure you work with + * it responsibly. In many cases, we will reuse the buffer to avoid fresh + * memory allocations, hence you have to pay attention to its usage pattern. + * It is not meant to be a general String replacement. + * + *

This class avoids many of the standard runtime checks that will result + * in a runtime or array exception anyway. Why check twice and raise the + * same exception? + * + * @author René Schwietzke + * @since 3.10.0 + */ +public class CheaperCharBuffer implements CharSequence { + // our data, can grow - that is not safe and has be altered from the original code + // to allow speed + public char[] data_; + + // the current size of the string data + public int length_; + + // the current size of the string data + private final int growBy_; + + // how much do we grow if needed, half a cache line + public static final int CAPACITY_GROWTH = 64 / 2; + + // what is our start size? + // a cache line is 64 byte mostly, the overhead is mostly 24 bytes + // a char is two bytes, let's use one cache lines + public static final int INITIAL_CAPACITY = (64 - 24) / 2; + + // static empty version; DON'T MODIFY IT + public static final CheaperCharBuffer EMPTY = new CheaperCharBuffer(0); + + // the � character + private static final char REPLACEMENT_CHARACTER = '\uFFFD'; + + /** + * Constructs an XMLCharBuffer with a default size. + */ + public CheaperCharBuffer() { + this.data_ = new char[INITIAL_CAPACITY]; + this.length_ = 0; + this.growBy_ = CAPACITY_GROWTH; + } + + /** + * Constructs an XMLCharBuffer with a desired size. + * + * @param startSize the size of the buffer to start with + */ + public CheaperCharBuffer(final int startSize) { + this(startSize, CAPACITY_GROWTH); + } + + /** + * Constructs an XMLCharBuffer with a desired size. + * + * @param startSize the size of the buffer to start with + * @param growBy by how much do we want to grow when needed + */ + public CheaperCharBuffer(final int startSize, final int growBy) { + this.data_ = new char[startSize]; + this.length_ = 0; + this.growBy_ = Math.max(1, growBy); + } + + /** + * Constructs an XMLCharBuffer from another buffer. Copies the data + * over. The new buffer capacity matches the length of the source. + * + * @param src the source buffer to copy from + */ + public CheaperCharBuffer(final CheaperCharBuffer src) { + this(src, 0); + } + + /** + * Constructs an XMLCharBuffer from another buffer. Copies the data + * over. You can add more capacity on top of the source length. If + * you specify 0, the capacity will match the src length. + * + * @param src the source buffer to copy from + * @param addCapacity how much capacity to add to origin length + */ + public CheaperCharBuffer(final CheaperCharBuffer src, final int addCapacity) { + this.data_ = Arrays.copyOf(src.data_, src.length_ + Math.max(0, addCapacity)); + this.length_ = src.length(); + this.growBy_ = Math.max(1, CAPACITY_GROWTH); + } + + /** + * Constructs an XMLCharBuffer from a string. To avoid + * too much allocation, we just take the string array as is and + * don't allocate extra space in the first place. + * + * @param src the string to copy from + */ + public CheaperCharBuffer(final String src) { + this.data_ = src.toCharArray(); + this.length_ = src.length(); + this.growBy_ = CAPACITY_GROWTH; + } + + /** + * Constructs an XMLString structure preset with the specified values. + * There will not be any room to grow, if you need that, construct an + * empty one and append. + * + *

There are not range checks performed. Make sure your data is correct. + * + * @param ch The character array, must not be null + * @param offset The offset into the character array. + * @param length The length of characters from the offset. + */ + public CheaperCharBuffer(final char[] ch, final int offset, final int length) { + // just as big as we need it + this(length); + append(ch, offset, length); + } + + /** + * Check capacity and grow if needed automatically + * + * @param minimumCapacity how much space do we need at least + */ + private void ensureCapacity(final int minimumCapacity) { + if (minimumCapacity > this.data_.length) { + final int newSize = Math.max(minimumCapacity + this.growBy_, (this.data_.length << 1) + 2); + this.data_ = Arrays.copyOf(this.data_, newSize); + } + } + + /** + * Returns the current max capacity without growth. Does not + * indicate how much capacity is already in use. Use {@link #length()} + * for that. + * + * @return the current capacity, not taken any usage into account + */ + public int capacity() { + return this.data_.length; + } + + /** + * Appends a single character to the buffer. + * + * @param c the character to append + * @return this instance + */ + public CheaperCharBuffer append(final char c) { + final int oldLength = this.length_++; + + // ensureCapacity is not inlined by the compiler, so put that here for the most + // called method of all appends. Duplicate code, but for a reason. + if (oldLength == this.data_.length) { + final int newSize = Math.max(oldLength + this.growBy_, (this.data_.length << 1) + 2); + this.data_ = Arrays.copyOf(this.data_, newSize); + } + + this.data_[oldLength] = c; + + return this; + } + + /** + * Append a string to this buffer without copying the string first. + * + * @param src the string to append + * @return this instance + */ + public CheaperCharBuffer append(final String src) { + final int start = this.length_; + this.length_ = this.length_ + src.length(); + ensureCapacity(this.length_); + + // copy char by char because we don't get a copy for free + // from a string yet, this might change when immutable arrays + // make it into Java, but that will not be very soon + for (int i = 0; i < src.length(); i++) { + this.data_[start + i] = src.charAt(i); + } + + return this; + } + + /** + * Add another buffer to this one. + * + * @param src the buffer to append + * @return this instance + */ + public CheaperCharBuffer append(final CheaperCharBuffer src) { + final int start = this.length_; + this.length_ = this.length_ + src.length(); + ensureCapacity(this.length_); + + System.arraycopy(src.data_, 0, this.data_, start, src.length_); + + return this; + } + + /** + * Add data from a char array to this buffer with the ability to specify + * a range to copy from + * + * @param src the source char array + * @param offset the pos to start to copy from + * @param length the length of the data to copy + * + * @return this instance + */ + public CheaperCharBuffer append(final char[] src, final int offset, final int length) { + final int start = this.length_; + this.length_ = start + length; + + ensureCapacity(this.length_); + + System.arraycopy(src, offset, this.data_, start, length); + + return this; + } + + /** + * Returns the current length + * + * @return the length of the charbuffer data + */ + public int length() { + return length_; + } + + /** + * Tell us how much the capacity grows if needed + * + * @return the value that determines how much we grow the backing + * array in case we have to + */ + public int getGrowBy() { + return this.growBy_; + } + + /** + * Resets the buffer to 0 length. It won't resize it to avoid memory + * churn. + * + * @return this instance for fluid programming + */ + public CheaperCharBuffer clear() { + this.length_ = 0; + + return this; + } + + /** + * Resets the buffer to 0 length and sets the new data. This + * is a little cheaper than clear().append(c) depending on + * the where and the inlining decisions. + * + * @param c the char to set + * @return this instance for fluid programming + */ + public CheaperCharBuffer clearAndAppend(final char c) { + this.length_ = 0; + + if (this.data_.length > 0) { + this.data_[this.length_] = c; + this.length_++; + } + else { + // the rare case when we don't have any buffer at hand + append(c); + } + + return this; + } + + /** + * Does this buffer end with this string? If we check for + * the empty string, we get true. If we would support JDK 11, we could + * use Arrays.mismatch and be way faster. + * + * @param s the string to check the end against + * @return true of the end matches the buffer, false otherwise + */ + public boolean endsWith(final String s) { + // length does not match, cannot be the end + if (this.length_ < s.length()) { + return false; + } + + // check the string by each char, avoids a copy of the string + final int start = this.length_ - s.length(); + + // change this to Arrays.mismatch when going JDK 11 or higher + for (int i = 0; i < s.length(); i++) { + if (this.data_[i + start] != s.charAt(i)) { + return false; + } + } + + return true; + } + + /** + * Reduces the buffer to the content between start and end marker when + * only whitespaces are found before the startMarker as well as after the end marker. + * If both strings overlap due to identical characters such as "foo" and "oof" + * and the buffer is " foof ", we don't do anything. + * + *

If a marker is empty, it behaves like {@link java.lang.String#trim()} on that side. + * + * @param startMarker the start string to find, must not be null + * @param endMarker the end string to find, must not be null + * @return this instance + * + * @deprecated Use the new method {@link #trimToContent(String, String)} instead. + */ + public CheaperCharBuffer reduceToContent(final String startMarker, final String endMarker) { + return trimToContent(startMarker, endMarker); + } + + /** + * Reduces the buffer to the content between start and end marker when + * only whitespaces are found before the startMarker as well as after the end marker. + * If both strings overlap due to identical characters such as "foo" and "oof" + * and the buffer is " foof ", we don't do anything. + * + *

If a marker is empty, it behaves like {@link java.lang.String#trim()} on that side. + * + * @param startMarker the start string to find, must not be null + * @param endMarker the end string to find, must not be null + * @return this instance + */ + public CheaperCharBuffer trimToContent(final String startMarker, final String endMarker) { + // if both are longer or same length than content, don't do anything + final int markerLength = startMarker.length() + endMarker.length(); + if (markerLength >= this.length_) { + return this; + } + + // run over starting whitespaces + int sPos = 0; + for (; sPos < this.length_ - markerLength; sPos++) { + if (!Character.isWhitespace(this.data_[sPos])) { + break; + } + } + + // run over ending whitespaces + int ePos = this.length_ - 1; + for (; ePos > sPos - markerLength; ePos--) { + if (!Character.isWhitespace(this.data_[ePos])) { + break; + } + } + + // if we have less content than marker length, give up + // this also helps when markers overlap such as + // and the string is " " + if (ePos - sPos + 1 < markerLength) { + return this; + } + + // check the start + for (int i = 0; i < startMarker.length(); i++) { + if (startMarker.charAt(i) != this.data_[i + sPos]) { + // no start match, stop and don't do anything + return this; + } + } + + // check the end, ePos is when the first good char + // occurred + final int endStartCheckPos = ePos - endMarker.length() + 1; + for (int i = 0; i < endMarker.length(); i++) { + if (endMarker.charAt(i) != this.data_[endStartCheckPos + i]) { + // no start match, stop and don't do anything + return this; + } + } + + // shift left and cut length + final int newLength = ePos - sPos + 1 - markerLength; + System.arraycopy(this.data_, + sPos + startMarker.length(), + this.data_, + 0, newLength); + this.length_ = newLength; + + return this; + } + + /** + * Check if we have only whitespaces + * + * @return true if we have only whitespace, false otherwise + */ + public boolean isWhitespace() { + for (int i = 0; i < this.length_; i++) { + if (!Character.isWhitespace(this.data_[i])) { + return false; + } + } + return true; + } + + /** + * Trims the string similar to {@link java.lang.String#trim()} + * + * @return a string with removed whitespace at the beginning and the end + */ + public CheaperCharBuffer trim() { + // clean the end first, because it is cheap + return trimTrailing().trimLeading(); + } + + /** + * Removes all whitespace before the first non-whitespace char. + * If all are whitespaces, we get an empty buffer + * + * @return this instance + */ + public CheaperCharBuffer trimLeading() { + // run over starting whitespace + int sPos = 0; + for (; sPos < this.length_; sPos++) { + if (!Character.isWhitespace(this.data_[sPos])) { + break; + } + } + + if (sPos == 0) { + // nothing to do + return this; + } + else if (sPos == this.length_) { + // only whitespace + this.length_ = 0; + return this; + } + + // shift left + final int newLength = this.length_ - sPos; + System.arraycopy(this.data_, + sPos, + this.data_, + 0, newLength); + this.length_ = newLength; + + return this; + } + + /** + * Removes all whitespace at the end. + * If all are whitespace, we get an empty buffer + * + * @return this instance + * + * @deprecated Use {@link #trimTrailing()} instead. + */ + public CheaperCharBuffer trimWhitespaceAtEnd() { + return trimTrailing(); + } + + /** + * Removes all whitespace at the end. + * If all are whitespace, we get an empty buffer + * + * @return this instance + */ + public CheaperCharBuffer trimTrailing() { + // run over ending whitespaces + int ePos = this.length_ - 1; + for (; ePos >= 0; ePos--) { + if (!Character.isWhitespace(this.data_[ePos])) { + break; + } + } + + this.length_ = ePos + 1; + + return this; + } + + /** + * Shortens the buffer by that many positions. If the count is + * larger than the length, we get just an empty buffer. If you pass in negative + * values, we are failing, likely often silently. It is all about performance and + * not a general all-purpose API. + * + * @param count a positive number, no runtime checks, if count is larger than + * length, we get length = 0 + * @return this instance + */ + public CheaperCharBuffer shortenBy(final int count) { + final int newLength = this.length_ - count; + this.length_ = newLength < 0 ? 0 : newLength; + + return this; + } + + /** + * Get the characters as char array, this will be a copy! + * + * @return a copy of the underlying char darta + */ + public char[] getChars() { + return Arrays.copyOf(this.data_, this.length_); + } + + /** + * Returns a string representation of this buffer. This will be a copy + * operation. If the buffer is emoty, we get a constant empty String back + * to avoid any overhead. + * + * @return a string of the content of this buffer + */ + @Override + public String toString() { + if (this.length_ > 0) { + return new String(this.data_, 0, this.length_); + } + else { + return ""; + } + } + + /** + * Returns the char a the given position. Will complain if + * we try to read outside the range. We do a range check here + * because we might not notice when we are within the buffer + * but outside the current length. + * + * @param index the position to read from + * @return the char at the position + * @throws IndexOutOfBoundsException + * in case one tries to read outside of valid buffer range + */ + @Override + public char charAt(final int index) { + if (index > this.length_ - 1 || index < 0) { + throw new IndexOutOfBoundsException( + "Tried to read outside of the valid buffer data"); + } + + return this.data_[index]; + } + + /** + * Returns the char at the given position. No checks are + * performed. It is up to the caller to make sure we + * read correctly. Reading outside of the array will + * cause an {@link IndexOutOfBoundsException} but using an + * incorrect position in the array (such as beyond length) + * might stay unnoticed! This is a performance method, + * use at your own risk. + * + * @param index the position to read from + * @return the char at the position + */ + public char unsafeCharAt(final int index) { + return this.data_[index]; + } + + /** + * Returns a content copy of this buffer + * + * @return a copy of this buffer, the capacity might differ + */ + @Override + public CheaperCharBuffer clone() { + return new CheaperCharBuffer(this); + } + + /** + * Returns a CharSequence that is a subsequence of this sequence. + * The subsequence starts with the char value at the specified index and + * ends with the char value at index end - 1. The length + * (in chars) of the + * returned sequence is end - start, so if start == end + * then an empty sequence is returned. + * + * @param start the start index, inclusive + * @param end the end index, exclusive + * + * @return the specified subsequence + * + * @throws IndexOutOfBoundsException + * if start or end are negative, + * if end is greater than length(), + * or if start is greater than end + * + * @return a charsequence of this buffer + */ + @Override + public CharSequence subSequence(final int start, final int end) { + if (start < 0) { + throw new StringIndexOutOfBoundsException(start); + } + if (end > this.length_) { + throw new StringIndexOutOfBoundsException(end); + } + + final int l = end - start; + if (l < 0) { + throw new StringIndexOutOfBoundsException(l); + } + + return new String(this.data_, start, l); + } + + /** + * Two buffers are identical when the length and + * the content of the backing array (only for the + * data in view) are identical. + * + * @param o the object to compare with + * @return true if length and array content match, false otherwise + */ + @Override + public boolean equals(final Object o) { + if (o instanceof CharSequence) { + final CharSequence ob = (CharSequence) o; + + if (ob.length() != this.length_) { + return false; + } + + // ok, in JDK 11 or up, we could use an + // Arrays.mismatch, but we cannot do that + // due to JDK 8 compatibility + for (int i = 0; i < this.length_; i++) { + if (ob.charAt(i) != this.data_[i]) { + return false; + } + } + + // length and content match, be happy + return true; + } + + return false; + } + + /** + * We don't cache the hashcode because we mutate often. Don't use this in + * hashmaps as key. But you can use that to look up in a hashmap against + * a string using the CharSequence interface. + * + * @return the hashcode, similar to what a normal string would deliver + */ + @Override + public int hashCode() { + int h = 0; + + for (int i = 0; i < this.length_; i++) { + h = ((h << 5) - h) + this.data_[i]; + } + + return h; + } + + /** + * Append a character to an XMLCharBuffer. The character is an int value, and + * can either be a single UTF-16 character or a supplementary character + * represented by two UTF-16 code points. + * + * @param value The character value. + * @return this instance for fluid programming + * + * @throws IllegalArgumentException if the specified + * {@code codePoint} is not a valid Unicode code point. + */ + public CheaperCharBuffer appendCodePoint(final int value) { + if (value <= Character.MAX_VALUE) { + return this.append((char) value); + } + else { + try { + final char[] chars = Character.toChars(value); + return this.append(chars, 0, chars.length); + } + catch (final IllegalArgumentException e) { + // when value is not valid as UTF-16 + this.append(REPLACEMENT_CHARACTER); + throw e; + } + } + } +} diff --git a/src/main/java/org/rschwietzke/FastRandom.java b/src/main/java/org/rschwietzke/FastRandom.java new file mode 100644 index 0000000..2d25d35 --- /dev/null +++ b/src/main/java/org/rschwietzke/FastRandom.java @@ -0,0 +1,76 @@ +/* + * Copyright 2023 The original authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.rschwietzke; + +/** + * Ultra-fast pseudo random generator that is not synchronized! + * Don't use anything from Random by inheritance, this will inherit + * a volatile! Not my idea, copyied in parts some demo random + * generator lessons. + * + * @author rschwietzke + * + */ +public class FastRandom { + private long seed; + + public FastRandom() { + this.seed = System.currentTimeMillis(); + } + + public FastRandom(long seed) { + this.seed = seed; + } + + protected int next(int nbits) { + // N.B. Not thread-safe! + long x = this.seed; + x ^= (x << 21); + x ^= (x >>> 35); + x ^= (x << 4); + this.seed = x; + + x &= ((1L << nbits) - 1); + + return (int) x; + } + + /** + * Borrowed from the JDK + * + * @param bound + * @return + */ + public int nextInt(int bound) { + int r = next(31); + int m = bound - 1; + if ((bound & m) == 0) // i.e., bound is a power of 2 + r = (int) ((bound * (long) r) >> 31); + else { + for (int u = r; u - (r = u % bound) + m < 0; u = next(31)) + ; + } + return r; + } + + /** + * Borrowed from the JDK + * @return + */ + public int nextInt() { + return next(32); + } +}