lol

Author: Mitron57

rust/benches/benchmarks/create.rs

@@ -1,11 +1,11 @@
 use {
-    linkspsql::{connect, Sql},
     criterion::{measurement::WallTime, BenchmarkGroup, Criterion},
     doublets::{data::LinkType, mem::Alloc, split, unit, Doublets},
     linkspsql::{
         benchmark, elapsed, prepare_file, Benched, Client, Fork, Result, Transaction,
         BACKGROUND_LINKS,
     },
+    linkspsql::{connect, Sql},
     std::{
         alloc::Global,
         time::{Duration, Instant},
@@ -14,7 +14,7 @@ use {
 };
 
 fn bench<S: Benched + Doublets<T>, T: LinkType>(
-    builder: S::Builder<'_>,
+    builder: S::Builder,
     id: &str,
     group: &mut BenchmarkGroup<WallTime>,
 ) -> Result<()> {
@@ -38,8 +38,8 @@ pub fn create_links(c: &mut Criterion) -> Result<()> {
     //let split_index = prepare_file("split_index.links")?;
     //bench::<Client<usize>, _>(&runtime, "PSQL_NonTransaction", &mut group).unwrap();
     {
-        let runtime = Runtime::new().unwrap();
-        let mut client = runtime.block_on(connect()).unwrap();
+        let runtime = Builder::new_multi_thread().enable_all().build().unwrap();
+        let mut client = connect(runtime).unwrap();
         bench::<Transaction<'_, usize>, _>(&mut client, "PSQL_Transaction", &mut group).unwrap();
     }
 

rust/src/benched.rs

@@ -12,9 +12,9 @@ use {
 };
 
 pub trait Benched: Sized {
-    type Builder<'a>;
+    type Builder;
 
-    fn setup(builder: Self::Builder<'_>) -> Result<Self>;
+    fn setup(builder: Self::Builder) -> Result<Self>;
 
     fn drop_storage(&mut self) -> Result<()>;
 
@@ -24,9 +24,9 @@ pub trait Benched: Sized {
 }
 
 impl<T: LinkType> Benched for unit::Store<T, FileMapped<LinkPart<T>>> {
-    type Builder<'a> = FileMapped<LinkPart<T>>;
+    type Builder = FileMapped<LinkPart<T>>;
 
-    fn setup(builder: Self::Builder<'_>) -> Result<Self> {
+    fn setup(builder: Self::Builder) -> Result<Self> {
         let mut links = Self::new(builder)?;
         for _ in 0..BACKGROUND_LINKS {
             links.create_point()?;
@@ -41,10 +41,10 @@ impl<T: LinkType> Benched for unit::Store<T, FileMapped<LinkPart<T>>> {
 }
 
 impl<T: LinkType> Benched for unit::Store<T, Alloc<LinkPart<T>, Global>> {
-    type Builder<'a> = Global;
+    type Builder = ();
 
-    fn setup(builder: Self::Builder<'_>) -> Result<Self> {
-        let storage = Alloc::new(builder);
+    fn setup(builder: Self::Builder) -> Result<Self> {
+        let storage = Alloc::new(Global);
         let mut links = Self::new(storage)?;
         for _ in 0..BACKGROUND_LINKS {
             links.create_point()?;
@@ -59,9 +59,9 @@ impl<T: LinkType> Benched for unit::Store<T, Alloc<LinkPart<T>, Global>> {
 }
 
 impl<T: LinkType> Benched for split::Store<T, FileMapped<DataPart<T>>, FileMapped<IndexPart<T>>> {
-    type Builder<'a> = (FileMapped<DataPart<T>>, FileMapped<IndexPart<T>>);
+    type Builder = (FileMapped<DataPart<T>>, FileMapped<IndexPart<T>>);
 
-    fn setup(builder: Self::Builder<'_>) -> Result<Self> {
+    fn setup(builder: Self::Builder) -> Result<Self> {
         let (data, index) = builder;
         let mut links = Self::new(data, index)?;
         for _ in 0..BACKGROUND_LINKS {
@@ -79,10 +79,10 @@ impl<T: LinkType> Benched for split::Store<T, FileMapped<DataPart<T>>, FileMappe
 impl<T: LinkType> Benched
     for split::Store<T, Alloc<DataPart<T>, Global>, Alloc<IndexPart<T>, Global>>
 {
-    type Builder<'a> = Global;
+    type Builder = ();
 
-    fn setup(builder: Self::Builder<'_>) -> Result<Self> {
-        let (data, index) = (Alloc::new(builder), Alloc::new(builder));
+    fn setup(builder: Self::Builder) -> Result<Self> {
+        let (data, index) = (Alloc::new(Global), Alloc::new(Global));
         let mut links = Self::new(data, index)?;
         for _ in 0..BACKGROUND_LINKS {
             links.create_point()?;
@@ -97,10 +97,10 @@ impl<T: LinkType> Benched
 }
 
 impl<T: LinkType> Benched for Client<T> {
-    type Builder<'a> = &'a Runtime;
+    type Builder = Runtime;
 
-    fn setup(builder: Self::Builder<'_>) -> Result<Self> {
-        let mut client = builder.block_on(connect())?;
+    fn setup(builder: Self::Builder) -> Result<Self> {
+        let mut client = connect(builder)?;
         for _ in 0..BACKGROUND_LINKS {
             client.create_point()?;
         }
@@ -118,9 +118,9 @@ impl<T: LinkType> Benched for Client<T> {
 }
 
 impl<'a, T: LinkType> Benched for Transaction<'a, T> {
-    type Builder<'b> = &'a mut Client<T>;
+    type Builder = &'a mut Client<T>;
 
-    fn setup(builder: Self::Builder<'_>) -> Result<Self> {
+    fn setup(builder: Self::Builder) -> Result<Self> {
         let mut transaction = builder.transaction().unwrap();
         transaction.create_table().unwrap();
         for _ in 0..BACKGROUND_LINKS {

rust/src/client.rs

@@ -16,8 +16,9 @@ pub struct Client<T: LinkType> {
 }
 
 impl<T: LinkType> Client<T> {
-    pub async fn new(client: postgres::Client) -> crate::Result<Self> {
-        client
+    pub fn new(client: postgres::Client, runtime: Runtime) -> crate::Result<Self> {
+        runtime.block_on(async {
+            client
             .query(
                 "CREATE TABLE IF NOT EXISTS Links (id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY, from_id bigint, to_id bigint);",
                 &[],
@@ -35,10 +36,12 @@ impl<T: LinkType> Client<T> {
                 &[],
             )
             .await?;
+            Ok::<(), postgres::Error>(())
+        })?;
         Ok(Self {
             client,
             constants: LinksConstants::<T>::new(),
-            runtime: Runtime::new()?,
+            runtime,
         })
     }
 
@@ -250,13 +253,13 @@ impl<T: LinkType> Links<T> for Client<T> {
                 old_links[0].get::<_, i64>(1).try_into().unwrap(),
                 old_links[0].get::<_, i64>(2).try_into().unwrap(),
             );
-            let _ = self
+            self
                 .client
                 .query(
                     "UPDATE Links SET from_id = $1, to_id = $2 WHERE id = $3;",
                     &[&source.as_i64(), &target.as_i64(), &id.as_i64()],
                 )
-                .await;
+                .await.unwrap();
             Ok(handler(
                 Link::new(id, old_source, old_target),
                 Link::new(id, source, target),

rust/src/lib.rs

@@ -31,7 +31,8 @@ macro_rules! benchmark {
 pub use {benched::Benched, client::Client, fork::Fork, transaction::Transaction};
 use {
     doublets::{data::LinkType, mem::FileMapped},
-    std::{fs::File, io, error::Error},
+    std::{error::Error, fs::File, io},
+    tokio::runtime::Runtime,
     tokio_postgres::NoTls,
 };
 
@@ -43,18 +44,22 @@ mod transaction;
 pub type Result<T> = core::result::Result<T, Box<dyn Error>>;
 
 pub const BACKGROUND_LINKS: usize = 3_000;
-const OPTIONS: &str = "user=postgres dbname=postgres password=postgres host=localhost port=5432";
+//const OPTIONS: &str = "user=postgres dbname=postgres password=postgres host=localhost port=5432";
+const OPTIONS: &str = "user=zaharyan dbname=zaharyan password=zaharyan host=localhost port=5432";
 
-pub async fn connect<T: LinkType>() -> Result<Client<T>> {
-    let (client, connection) = tokio_postgres::connect(OPTIONS, NoTls).await?;
-    tokio::spawn(async move {
-        if let Err(e) = connection.await {
-            eprintln!("Connection error: {e}");
-            return Err(e);
-        }
-        Ok(())
+pub fn connect<T: LinkType>(runtime: Runtime) -> Result<Client<T>> {
+    let client = runtime.block_on(async {
+        let (client, connection) = tokio_postgres::connect(OPTIONS, NoTls).await.unwrap();
+        tokio::spawn(async move {
+            if let Err(e) = connection.await {
+                eprintln!("Connection error: {e}");
+                return Err(e);
+            }
+            Ok(())
+        });
+        client
     });
-    Client::new(client).await
+    Client::new(client, runtime)
 }
 
 pub fn prepare_file<T: Default>(filename: &str) -> io::Result<FileMapped<T>> {