mesh-rb 0.0.1

data/ext/mesh/mesh/WORKSPACE

@@ -0,0 +1,50 @@
+# Copyright 2020 The Mesh Authors. All rights reserved.
+# Use of this source code is governed by the Apache License,
+# Version 2.0, that can be found in the LICENSE file.
+
+workspace(name = "org_libmesh")
+
+load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
+
+commit = {
+    "rules_cc": "5cbd3dfbd1613f71ef29bbb7b10310b81e272975",
+    "googletest": "c6e309b268d4fb9138bed7d0f56b7709c29f102f",
+    "benchmark": "15e6dfd7182b74b4fb6860f52fe314d0654307fb",
+    "heap_layers": "08ca96cfe11b1dd1c504fb7be613ad00756d568f",
+}
+
+http_archive(
+    name = "rules_cc",
+    sha256 = "d6775fe03da086dfe47c668f54e77e220aa6e601a66a4517eaf19fa1d9fda309",
+    strip_prefix = "rules_cc-{}".format(commit["rules_cc"]),
+    urls = [
+        "https://github.com/bazelbuild/rules_cc/archive/{}.zip".format(commit["rules_cc"]),
+    ],
+)
+
+http_archive(
+    name = "com_google_googletest",
+    sha256 = "ac0b859e4c28af555657c7702523465756eb56f8606bf53e62fd934c86b5fa5f",
+    strip_prefix = "googletest-{}".format(commit["googletest"]),
+    urls = [
+        "https://github.com/google/googletest/archive/{}.zip".format(commit["googletest"]),
+    ],
+)
+
+http_archive(
+    name = "com_google_benchmark",
+    # sha256 = "",
+    strip_prefix = "benchmark-{}".format(commit["benchmark"]),
+    urls = [
+        "https://github.com/google/benchmark/archive/{}.zip".format(commit["benchmark"]),
+    ],
+)
+
+http_archive(
+    name = "org_heaplayers",
+    sha256 = "c8a9f7589e13112515ba1ac8647b4e80462f18a6773f7f5f132a7d7602fe2aec",
+    strip_prefix = "Heap-Layers-{}".format(commit["heap_layers"]),
+    urls = [
+        "https://github.com/emeryberger/Heap-Layers/archive/{}.zip".format(commit["heap_layers"]),
+    ],
+)

data/ext/mesh/mesh/bazel

@@ -0,0 +1,350 @@
+#!/usr/bin/env python3
+"""
+Copyright 2018 Google Inc. All rights reserved.
+
+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.
+"""
+
+from contextlib import closing
+from distutils.version import LooseVersion
+import json
+import os
+import os.path
+import platform
+import re
+import shutil
+import subprocess
+import sys
+import tempfile
+import time
+
+try:
+    from urllib.request import urlopen
+except ImportError:
+    # Python 2.x compatibility hack.
+    from urllib2 import urlopen
+
+ONE_HOUR = 1 * 60 * 60
+
+LATEST_PATTERN = re.compile(r"latest(-(?P<offset>\d+))?$")
+
+LAST_GREEN_COMMIT_BASE_PATH = (
+    "https://storage.googleapis.com/bazel-untrusted-builds/last_green_commit/"
+)
+
+LAST_GREEN_COMMIT_PATH_SUFFIXES = {
+    "last_green": "github.com/bazelbuild/bazel.git/bazel-bazel",
+    "last_downstream_green": "downstream_pipeline",
+}
+
+BAZEL_GCS_PATH_PATTERN = (
+    "https://storage.googleapis.com/bazel-builds/artifacts/{platform}/{commit}/bazel"
+)
+
+SUPPORTED_PLATFORMS = {"linux": "ubuntu1404", "windows": "windows", "darwin": "macos"}
+
+TOOLS_BAZEL_PATH = "./tools/bazel"
+
+BAZEL_REAL = "BAZEL_REAL"
+
+
+def decide_which_bazel_version_to_use():
+    # Check in this order:
+    # - env var "USE_BAZEL_VERSION" is set to a specific version.
+    # - env var "USE_NIGHTLY_BAZEL" or "USE_BAZEL_NIGHTLY" is set -> latest
+    #   nightly. (TODO)
+    # - env var "USE_CANARY_BAZEL" or "USE_BAZEL_CANARY" is set -> latest
+    #   rc. (TODO)
+    # - the file workspace_root/tools/bazel exists -> that version. (TODO)
+    # - workspace_root/.bazelversion exists -> read contents, that version.
+    # - workspace_root/WORKSPACE contains a version -> that version. (TODO)
+    # - fallback: latest release
+    if "USE_BAZEL_VERSION" in os.environ:
+        return os.environ["USE_BAZEL_VERSION"]
+
+    workspace_root = find_workspace_root()
+    if workspace_root:
+        bazelversion_path = os.path.join(workspace_root, ".bazelversion")
+        if os.path.exists(bazelversion_path):
+            with open(bazelversion_path, "r") as f:
+                return f.read().strip()
+
+    return "latest"
+
+
+def find_workspace_root(root=None):
+    if root is None:
+        root = os.getcwd()
+    if os.path.exists(os.path.join(root, "WORKSPACE")):
+        return root
+    new_root = os.path.dirname(root)
+    return find_workspace_root(new_root) if new_root != root else None
+
+
+def resolve_version_label_to_number_or_commit(bazelisk_directory, version):
+    """Resolves the given label to a released version of Bazel or a commit.
+
+    Args:
+        bazelisk_directory: string; path to a directory that can store
+            temporary data for Bazelisk.
+        version: string; the version label that should be resolved.
+    Returns:
+        A (string, bool) tuple that consists of two parts:
+        1. the resolved number of a Bazel release (candidate), or the commit
+            of an unreleased Bazel binary,
+        2. An indicator for whether the returned version refers to a commit.
+    """
+    suffix = LAST_GREEN_COMMIT_PATH_SUFFIXES.get(version)
+    if suffix:
+        return get_last_green_commit(suffix), True
+
+    if "latest" in version:
+        match = LATEST_PATTERN.match(version)
+        if not match:
+            raise Exception(
+                'Invalid version "{}". In addition to using a version '
+                'number such as "0.20.0", you can use values such as '
+                '"latest" and "latest-N", with N being a non-negative '
+                "integer.".format(version)
+            )
+
+        history = get_version_history(bazelisk_directory)
+        offset = int(match.group("offset") or "0")
+        return resolve_latest_version(history, offset), False
+
+    return version, False
+
+
+def get_last_green_commit(path_suffix):
+    return read_remote_text_file(LAST_GREEN_COMMIT_BASE_PATH + path_suffix).strip()
+
+
+def get_releases_json(bazelisk_directory):
+    """Returns the most recent versions of Bazel, in descending order."""
+    releases = os.path.join(bazelisk_directory, "releases.json")
+
+    # Use a cached version if it's fresh enough.
+    if os.path.exists(releases):
+        if abs(time.time() - os.path.getmtime(releases)) < ONE_HOUR:
+            with open(releases, "rb") as f:
+                try:
+                    return json.loads(f.read().decode("utf-8"))
+                except ValueError:
+                    print("WARN: Could not parse cached releases.json.")
+                    pass
+
+    with open(releases, "wb") as f:
+        body = read_remote_text_file("https://api.github.com/repos/bazelbuild/bazel/releases")
+        f.write(body.encode("utf-8"))
+        return json.loads(body)
+
+
+def read_remote_text_file(url):
+    with closing(urlopen(url)) as res:
+        body = res.read()
+        try:
+            return body.decode(res.info().get_content_charset("iso-8859-1"))
+        except AttributeError:
+            # Python 2.x compatibility hack
+            return body.decode(res.info().getparam("charset") or "iso-8859-1")
+
+
+def get_version_history(bazelisk_directory):
+    ordered = sorted(
+        (
+            LooseVersion(release["tag_name"])
+            for release in get_releases_json(bazelisk_directory)
+            if not release["prerelease"]
+        ),
+        reverse=True,
+    )
+    return [str(v) for v in ordered]
+
+
+def resolve_latest_version(version_history, offset):
+    if offset >= len(version_history):
+        version = "latest-{}".format(offset) if offset else "latest"
+        raise Exception(
+            'Cannot resolve version "{}": There are only {} Bazel '
+            "releases.".format(version, len(version_history))
+        )
+
+    # This only works since we store the history in descending order.
+    return version_history[offset]
+
+
+def get_operating_system():
+    operating_system = platform.system().lower()
+    if operating_system not in ("linux", "darwin", "windows"):
+        raise Exception(
+            'Unsupported operating system "{}". '
+            "Bazel currently only supports Linux, macOS and Windows.".format(operating_system)
+        )
+    return operating_system
+
+
+def determine_bazel_filename(version):
+    machine = normalized_machine_arch_name()
+    if machine != "x86_64":
+        raise Exception(
+            'Unsupported machine architecture "{}". Bazel currently only supports x86_64.'.format(
+                machine
+            )
+        )
+
+    operating_system = get_operating_system()
+
+    filename_ending = ".exe" if operating_system == "windows" else ""
+    return "bazel-{}-{}-{}{}".format(version, operating_system, machine, filename_ending)
+
+
+def normalized_machine_arch_name():
+    machine = platform.machine().lower()
+    if machine == "amd64":
+        machine = "x86_64"
+    return machine
+
+
+def determine_url(version, is_commit, bazel_filename):
+    if is_commit:
+        sys.stderr.write("Using unreleased version at commit {}\n".format(version))
+        # No need to validate the platform thanks to determine_bazel_filename().
+        return BAZEL_GCS_PATH_PATTERN.format(
+            platform=SUPPORTED_PLATFORMS[platform.system().lower()], commit=version
+        )
+
+    # Split version into base version and optional additional identifier.
+    # Example: '0.19.1' -> ('0.19.1', None), '0.20.0rc1' -> ('0.20.0', 'rc1')
+    (version, rc) = re.match(r"(\d*\.\d*(?:\.\d*)?)(rc\d+)?", version).groups()
+    return "https://releases.bazel.build/{}/{}/{}".format(
+        version, rc if rc else "release", bazel_filename
+    )
+
+
+def download_bazel_into_directory(version, is_commit, directory):
+    bazel_filename = determine_bazel_filename(version)
+    url = determine_url(version, is_commit, bazel_filename)
+    destination_path = os.path.join(directory, bazel_filename)
+    if not os.path.exists(destination_path):
+        sys.stderr.write("Downloading {}...\n".format(url))
+        with tempfile.NamedTemporaryFile(prefix="bazelisk", dir=directory, delete=False) as t:
+            with closing(urlopen(url)) as response:
+                shutil.copyfileobj(response, t)
+            t.flush()
+            os.fsync(t.fileno())
+        os.rename(t.name, destination_path)
+    os.chmod(destination_path, 0o755)
+    return destination_path
+
+
+def get_bazelisk_directory():
+    bazelisk_home = os.environ.get("BAZELISK_HOME")
+    if bazelisk_home is not None:
+        return bazelisk_home
+
+    operating_system = get_operating_system()
+
+    base_dir = None
+
+    if operating_system == "windows":
+        base_dir = os.environ.get("LocalAppData")
+        if base_dir is None:
+            raise Exception("%LocalAppData% is not defined")
+    elif operating_system == "darwin":
+        base_dir = os.environ.get("HOME")
+        if base_dir is None:
+            raise Exception("$HOME is not defined")
+        base_dir = os.path.join(base_dir, "Library/Caches")
+    elif operating_system == "linux":
+        base_dir = os.environ.get("XDG_CACHE_HOME")
+        if base_dir is None:
+            base_dir = os.environ.get("HOME")
+            if base_dir is None:
+                raise Exception("neither $XDG_CACHE_HOME nor $HOME are defined")
+            base_dir = os.path.join(base_dir, ".cache")
+    else:
+        raise Exception("Unsupported operating system '{}'".format(operating_system))
+
+    return os.path.join(base_dir, "bazelisk")
+
+
+def maybe_makedirs(path):
+    """
+  Creates a directory and its parents if necessary.
+  """
+    try:
+        os.makedirs(path)
+    except OSError as e:
+        if not os.path.isdir(path):
+            raise e
+
+
+def delegate_tools_bazel(bazel_path):
+    """Match Bazel's own delegation behavior in the builds distributed by most
+    package managers: use tools/bazel if it's present, executable, and not this
+    script.
+    """
+    root = find_workspace_root()
+    if root:
+        wrapper = os.path.join(root, TOOLS_BAZEL_PATH)
+        if os.path.exists(wrapper) and os.access(wrapper, os.X_OK):
+            try:
+                if not os.path.samefile(wrapper, __file__):
+                    return wrapper
+            except AttributeError:
+                # Python 2 on Windows does not support os.path.samefile
+                if os.path.abspath(wrapper) != os.path.abspath(__file__):
+                    return wrapper
+    return None
+
+
+def execute_bazel(bazel_path, argv):
+    wrapper = delegate_tools_bazel(bazel_path)
+    if wrapper:
+        os.putenv(BAZEL_REAL, bazel_path)
+        bazel_path = wrapper
+
+    # We cannot use close_fds on Windows, so disable it there.
+    p = subprocess.Popen([bazel_path] + argv, close_fds=os.name != "nt")
+    while True:
+        try:
+            return p.wait()
+        except KeyboardInterrupt:
+            # Bazel will also get the signal and terminate.
+            # We should continue waiting until it does so.
+            pass
+
+
+def get_bazel_path():
+    bazelisk_directory = get_bazelisk_directory()
+    maybe_makedirs(bazelisk_directory)
+
+    bazel_version = decide_which_bazel_version_to_use()
+    bazel_version, is_commit = resolve_version_label_to_number_or_commit(
+        bazelisk_directory, bazel_version
+    )
+
+    bazel_directory = os.path.join(bazelisk_directory, "bin")
+    maybe_makedirs(bazel_directory)
+    return download_bazel_into_directory(bazel_version, is_commit, bazel_directory)
+
+
+def main(argv=None):
+    if argv is None:
+        argv = sys.argv
+
+    return execute_bazel(get_bazel_path(), argv[1:])
+
+
+if __name__ == "__main__":
+    sys.exit(main())

data/ext/mesh/mesh/src/BUILD

@@ -0,0 +1,222 @@
+# Copyright 2020 The Mesh Authors. All rights reserved.
+# Use of this source code is governed by the Apache License,
+# Version 2.0, that can be found in the LICENSE file.
+
+load("//src:copts.bzl", "MESH_DEFAULT_COPTS")
+
+package(default_visibility = ["//visibility:private"])
+
+licenses(["notice"])  # Apache 2.0
+
+# used in copts.bzl to set llvm/gcc-only flags
+config_setting(
+    name = "llvm",
+    flag_values = {
+        "@bazel_tools//tools/cpp:compiler": "llvm",
+    },
+    visibility = ["//visibility:private"],
+)
+
+config_setting(
+    name = "disable_meshing",
+    values = {
+        "define": "disable_meshing=true",
+    },
+    visibility = ["//visibility:private"],
+)
+
+config_setting(
+    name = "disable_randomization",
+    values = {
+        "define": "disable_randomization=true",
+    },
+    visibility = ["//visibility:private"],
+)
+
+config_setting(
+    name = "shuffle_on_free",
+    values = {
+        "define": "shuffle_on_free=true",
+    },
+    visibility = ["//visibility:private"],
+)
+
+NO_BUILTIN_MALLOC = [
+    "-fno-builtin-malloc",
+    "-fno-builtin-free",
+]
+
+COMMON_DEFINES = [] + select({
+    ":disable_meshing": ["MESHING_ENABLED=0"],
+    "//conditions:default": ["MESHING_ENABLED=1"],
+}) + select({
+    ":disable_randomization": ["SHUFFLE_ON_INIT=0"],
+    "//conditions:default": ["SHUFFLE_ON_INIT=1"],
+}) + select({
+    ":shuffle_on_free": ["SHUFFLE_ON_FREE=1"],
+    "//conditions:default": ["SHUFFLE_ON_FREE=0"],
+}) + select({
+    "@bazel_tools//src/conditions:linux_x86_64": [
+        # "_FORTIFY_SOURCE=2",  # TODO: only in release; but I think Bazel takes care of this?
+        "_DEFAULT_SOURCE",
+        "_BSD_SOURCE",
+        "_XOPEN_SOURCE=700",
+    ],
+    "//conditions:default": [],
+})
+
+COMMON_LINKOPTS = [
+    "-lm",
+    "-lpthread",
+    "-ldl",
+] + select({
+    "@bazel_tools//src/conditions:linux_x86_64": [
+        "-Wl,--no-as-needed",
+        "-Wl,--no-add-needed",
+        "-Wl,--sort-common",
+        "-Wl,--hash-style=both",
+        "-Wl,--no-undefined",
+        "-Wl,-Bsymbolic-functions",
+        "-Wl,-z,now,-z,relro",
+        "-Wl,--exclude-libs=libc++.a",
+        "-Wl,--exclude-libs=libc++abi.a",
+        "-Wl,--exclude-libs=libunwind.a",
+    ],
+    "//conditions:default": [],
+})
+
+cc_library(
+    name = "mesh-core",
+    srcs = [
+        "d_assert.cc",
+        "global_heap.cc",
+        "measure_rss.cc",
+        "meshable_arena.cc",
+        "real.cc",
+        "runtime.cc",
+        "thread_local_heap.cc",
+    ],
+    hdrs = glob([
+        "*.h",
+        "plasma/*.h",
+        "rng/*.h",
+        "gnu_wrapper.cc",
+        "mac_wrapper.cc",
+        "rpl_printf.c",
+        "static/*.h",
+        "size_classes.def",
+    ]),
+    copts = NO_BUILTIN_MALLOC + MESH_DEFAULT_COPTS,
+    defines = COMMON_DEFINES,
+    linkopts = COMMON_LINKOPTS,
+    linkstatic = True,
+    visibility = ["//visibility:private"],
+    deps = [
+        "@org_heaplayers",
+    ],
+)
+
+cc_library(
+    name = "mesh-lib",
+    srcs = [
+        "libmesh.cc",
+    ],
+    hdrs = glob([
+        "*.h",
+        "plasma/*.h",
+        "rng/*.h",
+        "gnu_wrapper.cc",
+        "mac_wrapper.cc",
+        "static/*.h",
+        "size_classes.def",
+        "wrapper.cc",
+    ]),
+    # TODO: config options here too
+    copts = NO_BUILTIN_MALLOC + MESH_DEFAULT_COPTS,
+    defines = COMMON_DEFINES,
+    linkopts = COMMON_LINKOPTS,
+    linkstatic = True,
+    visibility = ["//visibility:private"],
+    deps = [
+        "@org_heaplayers",
+    ],
+)
+
+cc_library(
+    name = "mesh",
+    srcs = [
+        "d_assert.cc",
+        "global_heap.cc",
+        "libmesh.cc",
+        "measure_rss.cc",
+        "meshable_arena.cc",
+        "real.cc",
+        "runtime.cc",
+        "thread_local_heap.cc",
+    ],
+    hdrs = glob([
+        "*.h",
+        "plasma/*.h",
+        "rng/*.h",
+        "gnu_wrapper.cc",
+        "mac_wrapper.cc",
+        "wrapper.cc",
+        "rpl_printf.c",
+        "static/*.h",
+        "size_classes.def",
+    ]),
+    copts = NO_BUILTIN_MALLOC + MESH_DEFAULT_COPTS,
+    defines = COMMON_DEFINES,
+    linkopts = COMMON_LINKOPTS + select({
+        "@bazel_tools//src/conditions:darwin": [
+            "-install_name /usr/local/lib/libmesh.dylib",
+            "-compatibility_version 1",
+            "-current_version 1",
+            "-ldl",
+        ],
+        "//conditions:default": [],
+    }),
+    linkstatic = False,
+    visibility = ["//visibility:public"],
+    # disabled, as we directly specify the source files above.
+    # this is to work around a bazel bug on macOS where if we
+    # specify only deps, it produces an empty dylib
+    # deps = [
+    #     ":mesh-core",
+    #     ":mesh-lib",
+    # ],
+    deps = [
+        "@org_heaplayers",
+    ],
+    # only valid for cc_library
+    alwayslink = 1,
+)
+
+cc_test(
+    name = "unit-tests",
+    srcs = glob([
+        "testing/unit/*.cc",
+    ]),
+    copts = [
+        "-Isrc",
+    ] + MESH_DEFAULT_COPTS,
+    linkopts = COMMON_LINKOPTS,
+    deps = [
+        ":mesh-core",
+        "@com_google_googletest//:gtest_main",
+    ],
+)
+
+cc_test(
+    name = "local-refill-benchmark",
+    srcs = ["testing/benchmark/local_refill.cc"],
+    copts = [
+        "-Isrc",
+    ] + NO_BUILTIN_MALLOC + MESH_DEFAULT_COPTS,
+    linkopts = COMMON_LINKOPTS,
+    deps = [
+        ":mesh-core",
+        "@com_google_benchmark//:benchmark",
+        "@com_google_googletest//:gtest_main",
+    ],
+)