init

Author: lgarithm

.gitignore

@@ -0,0 +1,8 @@
+/Makefile
+CTestTestfile.cmake
+Testing/
+*.a
+generated
+*.so
+*.dylib
+/3rdparty

CMakeLists.txt

@@ -0,0 +1,49 @@
+CMAKE_MINIMUM_REQUIRED(VERSION 3.10)
+PROJECT(pytorch-quiver)
+
+SET(CMAKE_CXX_STANDARD 17)
+SET(CMAKE_RUNTIME_OUTPUT_DIRECTORY bin)
+SET(CMAKE_BUILD_TYPE Release)
+SET(CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/srcs/cmake)
+
+OPTION(USE_STRICT "Enable strict build options." OFF)
+IF(USE_STRICT)
+    ADD_DEFINITIONS(-Wall)
+    ADD_DEFINITIONS(-Werror)
+    ADD_DEFINITIONS(-Wfatal-errors)
+ENDIF()
+
+INCLUDE_DIRECTORIES(cuda-sample ${CMAKE_SOURCE_DIR}/srcs/cpp/include)
+
+FIND_PACKAGE(stdtracer REQUIRED)
+
+IF(ENABLE_CUDA)
+    INCLUDE(srcs/cmake/cuda.cmake)
+ENDIF()
+IF(BUILD_TORCH_EXTENSION)
+    INCLUDE(srcs/cmake/torch.cmake)
+ENDIF()
+
+FUNCTION(ADD_SOURCE target)
+    TARGET_SOURCES(${target} PRIVATE ${ARGN})
+ENDFUNCTION()
+
+ADD_LIBRARY(quiver SHARED)
+ADD_SOURCE(quiver ${CMAKE_SOURCE_DIR}/srcs/cpp/src/quiver/quiver.cpp)
+IF(ENABLE_CUDA)
+    ADD_SOURCE(quiver ${CMAKE_SOURCE_DIR}/srcs/cpp/src/quiver/cuda/quiver.cu)
+ENDIF()
+
+# ADD_EXECUTABLE(example examples/cpp/torch-example.cpp)
+# TARGET_LINK_LIBRARIES(example c10) TARGET_LINK_LIBRARIES(example torch)
+
+ADD_EXECUTABLE(cpu-sample examples/cpu_sample.cpp)
+ADD_EXECUTABLE(quiver-example examples/quiver_example.cpp)
+TARGET_LINK_LIBRARIES(quiver-example quiver)
+TARGET_USE_STDTRACER(quiver-example)
+
+IF(ENABLE_CUDA)
+    ADD_EXECUTABLE(cuda-sample examples/cuda_sample.cpp)
+ENDIF()
+
+ENABLE_TESTING()

README

@@ -0,0 +1,10 @@
+Quiver
+
+Graph Neural Network Operators for heterogeneous hardware.
+
+code structure
+
+*.cu.hpp // cuda template
+*.hpp // c++ header or template
+*.cu  // cuda kernels
+*.cpp // c++ implementations

REFERENCE

@@ -0,0 +1 @@
+https://docs.nvidia.com/cuda/cusparse/index.html

U

@@ -0,0 +1,18 @@
+#!/bin/sh
+set -e
+
+notify() {
+    if [ -f ~/.slack/notify ]; then
+        ~/.slack/notify "$@"
+    fi
+}
+
+. ./scripts/measure.sh
+
+# [done] q $ pip3 install --no-index -U . took 42s
+# measure pip3 install --no-index -U .
+
+p=$(basename $(pwd))
+notify "Building $p from $(hostname)"
+measure pip3 install --no-index -U .
+notify "Built $p from $(hostname)"

auto/cmake

@@ -0,0 +1,64 @@
+# -*- mode: sh -*-
+
+QUIET=0
+
+CMAKE_FLAGS=
+
+add_cmake_flag() {
+    if [ $QUIET -eq 0 ]; then
+        echo "Using $1=$2"
+    fi
+    CMAKE_FLAGS="${CMAKE_FLAGS} -D$1=$2"
+}
+
+pass_cmake_flag_from_env() {
+    local name=$1
+    local env_key=$2
+    if [ -z ${env_key} ]; then
+        env_key=$name
+    fi
+    local val=$(eval echo \$$env_key)
+    if [ ! -z "$val" ]; then
+        add_cmake_flag $name $val
+    fi
+}
+
+CMAKE_PREFIX_PATH=
+
+add_cmake_prefix() {
+    if [ $QUIET -eq 0 ]; then
+        echo "adding to CMAKE_PREFIX_PATH with $1"
+    fi
+    CMAKE_PREFIX_PATH="$CMAKE_PREFIX_PATH;$1"
+}
+
+cleanup_cmake_cache() {
+    if [ -f CMakeCache.txt ]; then
+        rm CMakeCache.txt
+    fi
+    if [ -d 3rdparty ]; then
+        for cmake_cache in $(find 3rdparty/ | grep CMakeCache.txt); do
+            rm $cmake_cache
+        done
+    fi
+}
+
+get_dep() {
+    local name=$1
+    head -n 1 ./deps/$name | awk '{print $1}'
+}
+
+log_config_var() {
+    local name=$1
+    local val=$(eval echo \$$name)
+    if [ $QUIET -eq 0 ]; then
+        echo "$name=$val"
+    fi
+}
+
+config_cmake() {
+    add_cmake_prefixes
+    add_cmake_flags
+    cleanup_cmake_cache
+    cmake . $CMAKE_FLAGS
+}

azure-pipelines.yml

@@ -0,0 +1,52 @@
+# Python package
+# Create and test a Python package on multiple Python versions.
+# Add steps that analyze code, save the dist with the build record, publish to a PyPI-compatible index, and more:
+# https://docs.microsoft.com/azure/devops/pipelines/languages/python
+
+trigger:
+- master
+
+pool:
+  vmImage: 'ubuntu-latest'
+
+strategy:
+  matrix:
+    Python36:
+      python.version: '3.6'
+
+steps:
+- task: UsePythonVersion@0
+  inputs:
+    versionSpec: '$(python.version)'
+  displayName: 'Use Python $(python.version)'
+
+- script: pip install -U pip
+  displayName: Upgrade pip
+
+- script: pip install -U wheel
+  displayName: Install wheel
+
+- script: pip install -U pytest
+  displayName: Install pytest
+
+- script: pip install -f https://download.pytorch.org/whl/torch_stable.html torch==1.6.0+cpu
+  displayName: Install PyTorch
+
+- script: ./configure && make -j $(nproc)
+  displayName: Build
+
+- script: git clean -fdx
+  displayName: Clean
+
+- script: pip install --no-index .
+  displayName: Install
+
+- script: |
+    python examples/e1.py
+  displayName: Run
+  timeoutInMinutes: 1
+
+- script: |
+    pytest
+  displayName: Test
+  timeoutInMinutes: 1

b

@@ -0,0 +1,4 @@
+#!/bin/sh
+set -e
+
+./benchmarks/bench-pyg-product.py 2> err.txt > out.txt

benchmarks/bench-pyg-product.py

@@ -0,0 +1,124 @@
+#!/usr/bin/env python3
+
+import copy
+import os
+import os.path as osp
+import time
+from typing import List, NamedTuple, Optional, Tuple
+
+import torch
+import torch_quiver as qv
+from ogb.nodeproppred import PygNodePropPredDataset
+
+
+def info(t, name=None):
+    msg = ''
+    if name:
+        msg += name
+    msg += ' ' + str(t.type())
+    msg += ' ' + str(t.shape)
+    print(msg)
+
+
+class CudaNeighborSampler(torch.utils.data.DataLoader):
+    def __init__(self,
+                 edge_index: torch.Tensor,
+                 sizes: List[int],
+                 node_idx: Optional[torch.Tensor] = None,
+                 num_nodes: Optional[int] = None,
+                 **kwargs):
+
+        N = int(edge_index.max() + 1) if num_nodes is None else num_nodes
+        print('building quiver')
+        t0 = time.time()
+        self.quiver = qv.new_quiver_from_edge_index(N, edge_index)
+        d = time.time() - t0
+        print('build quiver took %fms' % (d * 1000))
+
+        if node_idx is None:
+            node_idx = torch.arange(N)
+        elif node_idx.dtype == torch.bool:
+            node_idx = node_idx.nonzero().view(-1)
+
+        self.sizes = sizes
+
+        super(CudaNeighborSampler, self).__init__(node_idx.tolist(),
+                                                  collate_fn=self.sample,
+                                                  **kwargs)
+
+    def sample(self, batch):
+        t0 = time.time()
+        ret = self._sample(batch)
+        d = time.time() - t0
+        print('sample took %fms' % (d * 1000))
+        return ret
+
+    def _sample(self, batch):
+        if not isinstance(batch, torch.Tensor):
+            batch = torch.tensor(batch)
+
+        batch_size: int = len(batch)
+        print('sample batch size %d' % (batch_size))
+
+        # adjs: List[Adj] = []
+
+        n_id = batch
+        for size in self.sizes:
+            result = self.quiver.sample_adj(n_id, size)
+            info(result)
+            n_id = result
+            # adj, n_id = self.adj.sample_adj(n_id, size, replace=False)
+        #     if self.flow == 'source_to_target':
+        #         adj = adj.t()
+        #     row, col, e_id = adj.coo()
+        #     size = adj.sparse_sizes()
+        #     edge_index = torch.stack([row, col], dim=0)
+
+        #     adjs.append(Adj(edge_index, e_id, size))
+
+        return batch_size, batch
+        # if len(adjs) > 1:
+        #     return batch_size, n_id, adjs[::-1]
+        # else:
+        #     return batch_size, n_id, adjs[0]
+
+    def __repr__(self):
+        return '{}(sizes={})'.format(self.__class__.__name__, self.sizes)
+
+
+def load_data():
+    home = os.getenv('HOME')
+    data_dir = os.path.join(home, '.pyg')
+    root = os.path.join(data_dir, 'data', 'products')
+    filename = os.path.join(
+        root, 'ogbn_products_pyg/processed/geometric_data_processed.pt')
+    data, _ = torch.load(filename)
+    return data.edge_index
+
+
+def load_dataset():
+    home = os.getenv('HOME')
+    data_dir = osp.join(home, '.pyg')
+    root = osp.join(data_dir, 'data', 'products')
+    dataset = PygNodePropPredDataset('ogbn-products', root)
+    split_idx = dataset.get_idx_split()
+    data = dataset[0]
+    return data, split_idx
+
+
+def main():
+    data, split_idx = load_dataset()
+    train_idx = split_idx['train']
+    sampler = CudaNeighborSampler(
+        data.edge_index,
+        node_idx=train_idx,
+        sizes=[15, 10, 5],
+        batch_size=1024,
+    )
+
+    # for idx, (batch_size, n_id, adjs) in enumerate(train_loader):
+    for idx, (batch_size, batch) in enumerate(sampler):
+        print('#%d' % (idx))
+
+
+main()

benchmarks/show-data-info.py

@@ -0,0 +1,47 @@
+#!/usr/bin/env python3
+
+import os
+
+import torch
+
+
+def info(t, name=None):
+    msg = ''
+    if name:
+        msg += name
+    msg += ' ' + str(t.type())
+    msg += ' ' + str(t.shape)
+    print(msg)
+
+
+def main():
+    home = os.getenv('HOME')
+    data_dir = os.path.join(home, '.pyg')
+    root = os.path.join(data_dir, 'data', 'products')
+    filename = os.path.join(
+        root, 'ogbn_products_pyg/processed/geometric_data_processed.pt')
+    print(filename)
+    data, kvs = torch.load(filename)
+    print(data.__class__)  # torch_geometric.data.data.Data
+
+    for idx, d in enumerate(dir(data)):
+        print('[%d]=%s' % (idx, d))
+
+    info(data.x, 'data.x')
+    info(data.y, 'data.y')
+    info(data.edge_index, 'data.edge_index')
+
+    for k, v in kvs.items():
+        print(k)
+        print(v.__class__)
+
+    info(kvs['x'], 'x')
+    info(kvs['y'], 'y')
+    info(kvs['edge_index'], 'edge_index')
+
+    print(kvs['x'])  # tensor([      0, 2449029])
+    print(kvs['y'])  # tensor([      0, 2449029])
+    print(kvs['edge_index'])  # tensor([        0, 123718280])
+
+
+main()