split out processing into a separate thread

Cargo.toml

@@ -1,42 +1,42 @@
 [package]
-name = "silk"
-description = "A silky smooth implementation of the Loom architecture"
+name = "solana"
+description = "High Performance Blockchain"
 version = "0.4.0"
-documentation = "https://docs.rs/silk"
+documentation = "https://docs.rs/solana"
 homepage = "http://loomprotocol.com/"
-repository = "https://github.com/loomprotocol/silk"
+repository = "https://github.com/solana-labs/solana"
 authors = [
-    "Anatoly Yakovenko <aeyakovenko@gmail.com>",
-    "Greg Fitzgerald <garious@gmail.com>",
+    "Anatoly Yakovenko <anatoly@solana.co>",
+    "Greg Fitzgerald <greg@solana.co>",
 ]
 license = "Apache-2.0"
 
 [[bin]]
-name = "silk-historian-demo"
+name = "solana-historian-demo"
 path = "src/bin/historian-demo.rs"
 
 [[bin]]
-name = "silk-client-demo"
+name = "solana-client-demo"
 path = "src/bin/client-demo.rs"
 
 [[bin]]
-name = "silk-testnode"
+name = "solana-testnode"
 path = "src/bin/testnode.rs"
 
 [[bin]]
-name = "silk-genesis"
+name = "solana-genesis"
 path = "src/bin/genesis.rs"
 
 [[bin]]
-name = "silk-genesis-demo"
+name = "solana-genesis-demo"
 path = "src/bin/genesis-demo.rs"
 
 [[bin]]
-name = "silk-mint"
+name = "solana-mint"
 path = "src/bin/mint.rs"
 
 [badges]
-codecov = { repository = "loomprotocol/silk", branch = "master", service = "github" }
+codecov = { repository = "solana-labs/solana", branch = "master", service = "github" }
 
 [features]
 unstable = []
@@ -54,4 +54,7 @@ untrusted = "0.5.1"
 bincode = "1.0.0"
 chrono = { version = "0.4.0", features = ["serde"] }
 log = "^0.4.1"
+env_logger = "^0.4.1"
 matches = "^0.1.6"
+byteorder = "^1.2.1"
+libc = "^0.2.1"

Makefile

@@ -0,0 +1,46 @@
+export RUST_LOG=solana::gpu=TRACE
+#export RUST_BACKTRACE=1
+
+all: htest
+
+htest:wfmt
+	#cargo test accountant_skel::tests::test_layout -- --nocapture 2>&1 | head -n 30
+	#cargo test accountant_skel::tests::test_layout -- --nocapture
+	cargo test accountant_stub -- --nocapture 2>&1 | head -n 30
+
+ci: test bench release clippy ipv6
+
+build:
+	cargo build 2>&1 | head -n 30
+
+loop:
+	while true; do fswatch -1 -r src; make; done 
+
+test:
+	cargo test
+
+clippy:
+	 cargo +nightly clippy --features="unstable"
+
+cov:
+	docker run -it --rm --security-opt seccomp=unconfined --volume "$$PWD:/volume" elmtai/docker-rust-kcov
+
+wfmt:
+	cargo fmt -- --write-mode=overwrite
+
+release:
+	cargo build --all-targets --release
+
+node:
+	cat genesis.log | cargo run --bin silk-testnode > transactions0.log
+
+bench:
+	cargo +nightly bench --features="unstable" -- --nocapture
+
+ipv6:
+	cargo test ipv6 --features="ipv6" -- --nocapture
+
+lib:libcuda_verify_ed25519.a
+libcuda_verify_ed25519.a:dummy.c
+	cc -o dummy.o -c dummy.c
+	ar -cvq libcuda_verify_ed25519.a dummy.o

README.md

@@ -1,25 +1,18 @@
-[![Silk crate](https://img.shields.io/crates/v/silk.svg)](https://crates.io/crates/silk)
-[![Silk documentation](https://docs.rs/silk/badge.svg)](https://docs.rs/silk)
-[![Build Status](https://travis-ci.org/loomprotocol/silk.svg?branch=master)](https://travis-ci.org/loomprotocol/silk)
-[![codecov](https://codecov.io/gh/loomprotocol/silk/branch/master/graph/badge.svg)](https://codecov.io/gh/loomprotocol/silk)
+[![Solana crate](https://img.shields.io/crates/v/solana.svg)](https://crates.io/crates/solana)
+[![Solana documentation](https://docs.rs/solana/badge.svg)](https://docs.rs/solana)
+[![Build Status](https://travis-ci.org/solana-labs/solana.svg?branch=master)](https://travis-ci.org/solana-labs/solana)
+[![codecov](https://codecov.io/gh/solana-labs/solana/branch/master/graph/badge.svg)](https://codecov.io/gh/solana-labs/solana)
 
 Disclaimer
 ===
 
 All claims, content, designs, algorithms, estimates, roadmaps, specifications, and performance measurements described in this project are done with the author's best effort.  It is up to the reader to check and validate their accuracy and truthfulness.  Furthermore nothing in this project constitutes a solicitation for investment.
 
-Silk, a silky smooth implementation of the Loom specification
+Solana: High Performance Blockchain
 ===
 
-Loom™ is a new architecture for a high performance blockchain. Its white paper boasts a theoretical
-throughput of 710k transactions per second on a 1 gbps network. The specification is implemented
-in two git repositories. Research is performed in the loom repository. That work drives the
-Loom specification forward. This repository, on the other hand, aims to implement the specification
-as-is.  We care a great deal about quality, clarity and short learning curve. We avoid the use
-of `unsafe` Rust and write tests for *everything*.  Optimizations are only added when
-corresponding benchmarks are also added that demonstrate real performance boosts. We expect the
-feature set here will always be a ways behind the loom repo, but that this is an implementation
-you can take to the bank, literally.
+Solana™ is a new architecture for a high performance blockchain. It aims to support
+over 700 thousand transactions per second on a gigabit network.
 
 Running the demo
 ===
@@ -31,34 +24,28 @@ $ curl https://sh.rustup.rs -sSf | sh
 $ source $HOME/.cargo/env
 ```
 
-Install the silk executables:
-
-```bash
-    $ cargo install silk
-```
-
 The testnode server is initialized with a ledger from stdin and
 generates new ledger entries on stdout. To create the input ledger, we'll need
 to create *the mint* and use it to generate a *genesis ledger*. It's done in
 two steps because the mint.json file contains a private key that will be
 used later in this demo.
 
 ```bash
-    $ echo 500 | silk-mint > mint.json
-    $ cat mint.json | silk-genesis > genesis.log
+    $ echo 1000000000 | cargo run --release --bin solana-mint | tee mint.json
+    $ cat mint.json | cargo run --release --bin solana-genesis | tee genesis.log
 ```
 
 Now you can start the server:
 
 ```bash
-    $ cat genesis.log | silk-testnode > transactions0.log
+    $ cat genesis.log | cargo run --release --bin solana-testnode | tee transactions0.log
 ```
 
 Then, in a separate shell, let's execute some transactions. Note we pass in
 the JSON configuration file here, not the genesis ledger.
 
 ```bash
-    $ cat mint.json | silk-client-demo
+    $ cat mint.json | cargo run --release --bin solana-client-demo
 ```
 
 Now kill the server with Ctrl-C, and take a look at the ledger. You should
@@ -74,14 +61,14 @@ Now restart the server from where we left off. Pass it both the genesis ledger,
 the transaction ledger.
 
 ```bash
-    $ cat genesis.log transactions0.log | silk-testnode > transactions1.log
+    $ cat genesis.log transactions0.log | cargo run --release --bin solana-testnode | tee transactions1.log
 ```
 
 Lastly, run the client demo again, and verify that all funds were spent in the
 previous round, and so no additional transactions are added.
 
 ```bash
-    $ cat mint.json | silk-client-demo
+    $ cat mint.json | cargo run --release --bin solana-client-demo
 ```
 
 Stop the server again, and verify there are only Tick entries, and no Transaction entries.
@@ -103,8 +90,8 @@ $ rustup component add rustfmt-preview
 Download the source code:
 
 ```bash
-$ git clone https://github.com/loomprotocol/silk.git
-$ cd silk
+$ git clone https://github.com/solana-labs/solana.git
+$ cd solana
 ```
 
 Testing

build.rs

@@ -0,0 +1,8 @@
+fn main() {
+    println!("cargo:rustc-link-search=native=.");
+    println!("cargo:rustc-link-lib=static=cuda_verify_ed25519");
+    println!("cargo:rustc-link-search=native=/usr/local/cuda/lib64");
+    println!("cargo:rustc-link-lib=dylib=cudart");
+    println!("cargo:rustc-link-lib=dylib=cuda");
+    println!("cargo:rustc-link-lib=dylib=cudadevrt");
+}

doc/consensus.msc

@@ -0,0 +1,15 @@
+msc {
+  client,leader,verifier_a,verifier_b,verifier_c;
+
+  client=>leader [ label = "SUBMIT" ] ;
+  leader=>client [ label = "CONFIRMED" ] ;
+  leader=>verifier_a [ label = "CONFIRMED" ] ;
+  leader=>verifier_b [ label = "CONFIRMED" ] ;
+  leader=>verifier_c [ label = "CONFIRMED" ] ;
+  verifier_a=>leader [ label = "VERIFIED" ] ;
+  verifier_b=>leader [ label = "VERIFIED" ] ;
+  leader=>client [ label = "FINALIZED" ] ;
+  leader=>verifier_a [ label = "FINALIZED" ] ;
+  leader=>verifier_b [ label = "FINALIZED" ] ;
+  leader=>verifier_c [ label = "FINALIZED" ] ;
+}

doc/historian.md

@@ -8,11 +8,11 @@ with by verifying each entry's hash can be generated from the hash in the previo
 ![historian](https://user-images.githubusercontent.com/55449/36950845-459bdb58-1fb9-11e8-850e-894586f3729b.png)
 
 ```rust
-extern crate silk;
+extern crate solana;
 
-use silk::historian::Historian;
-use silk::ledger::{verify_slice, Entry, Hash};
-use silk::event::{generate_keypair, get_pubkey, sign_claim_data, Event};
+use solana::historian::Historian;
+use solana::ledger::{Block, Entry, Hash};
+use solana::event::{generate_keypair, get_pubkey, sign_claim_data, Event};
 use std::thread::sleep;
 use std::time::Duration;
 use std::sync::mpsc::SendError;
@@ -38,7 +38,7 @@ fn main() {
     }
     // Proof-of-History: Verify the historian learned about the events
     // in the same order they appear in the vector.
-    assert!(verify_slice(&entries, &seed));
+    assert!(entries[..].verify(&seed));
 }
 ```
 
@@ -56,7 +56,7 @@ Proof-of-History
 Take note of the last line:
 
 ```rust
-assert!(verify_slice(&entries, &seed));
+assert!(entries[..].verify(&seed));
 ```
 
 [It's a proof!](https://en.wikipedia.org/wiki/Curry–Howard_correspondence) For each entry returned by the

doc/historian.msc

@@ -14,5 +14,5 @@ msc {
   recorder=>historian [ label = "e2 = Entry{id: h6, n: 3, event: Tick}" ] ;
   client=>historian [ label = "collect()" ] ;
   historian=>client [ label = "entries = [e0, e1, e2]" ] ;
-  client=>client [ label = "verify_slice(entries, h0)" ] ;
+  client=>client [ label = "entries.verify(h0)" ] ;
 }

dummy.c

@@ -0,0 +1,51 @@
+#include <stdint.h>
+#include <assert.h>
+#include <stdio.h>
+
+#define PACKET_SIZE 288
+#define PACKET_DATA_SIZE 256
+union Packet {
+    char data[PACKET_DATA_SIZE];
+    char total[PACKET_SIZE];
+};
+
+struct Elems {
+    union Packet *packet;
+    uint32_t len;
+};
+
+int ed25519_verify_many(                                                    
+    const struct Elems *vecs,                                                    
+    uint32_t num,
+    uint32_t message_size,
+    uint32_t public_key_offset,
+    uint32_t signature_offset,
+    uint32_t signed_message_offset,
+    uint32_t signed_message_len_offset,
+    uint8_t *out
+) {
+    int i, p = 0;
+    assert(num > 0);
+    for(i = 0; i < num; ++i) {
+        int j;
+        assert(vecs[i].len > 0);
+        assert(message_size == PACKET_SIZE);
+        assert(signed_message_len_offset == PACKET_DATA_SIZE);
+        for(j = 0; j < vecs[i].len; ++j) { 
+            uint32_t *len = (uint32_t*)&vecs[i].packet[j].total[signed_message_len_offset];
+            assert(*len <= PACKET_DATA_SIZE);
+            p += 1;
+            if(public_key_offset > *len - 32) {
+                continue;
+            }
+            if(signature_offset > *len - 64) {
+                continue;
+            }
+            if(signed_message_offset > *len) {
+                continue;
+            }
+            out[p - 1] = 1;
+        }
+    }
+    return 0; 
+}