Added moderate heavy workload;

Fixed bug that made find_in go from O(n) to O(log n)

Author: sooraj-srini

bench/bench_atomic_skiplist.ml

@@ -25,13 +25,13 @@ let write_heavy_workload () =
 (* A regular workload with 90% reads, 9% adds and 1% removes. *)
 let read_heavy_workload () = 
   let sl = Atomicskiplist.create () in
-  let elems = Array.init num_elems (fun _ -> Random.int 100) in 
+  let elems = Array.init num_elems (fun _ -> Random.int 10000) in 
   let push = (fun () -> Domain.spawn ( fun () ->
     let start_time = Unix.gettimeofday () in 
     for i = 0 to (num_elems - 1) do ( 
       if i mod 1000 < 90 then 
         Atomicskiplist.add sl elems.(i) |> ignore
-      else if i mod 1000 > 90 && i mod 1000 < 100 then 
+      else if i mod 1000 >= 90 && i mod 1000 < 100 then 
         Atomicskiplist.remove sl elems.(i) |> ignore
       else 
         Atomicskiplist.find sl elems.(i) |> ignore
@@ -44,14 +44,39 @@ let read_heavy_workload () =
   let end_time = Unix.gettimeofday () in 
   let time_diff = end_time -. (List.nth start_time_threads 0) in 
   time_diff
-
+  
+  
+  let moderate_heavy_workload () = 
+    let sl = Atomicskiplist.create () in
+    let elems = Array.init num_elems (fun _ -> Random.int 10000) in 
+    let push = (fun () -> Domain.spawn ( fun () ->
+      let start_time = Unix.gettimeofday () in 
+      for i = 0 to (num_elems - 1) do ( 
+        if i mod 1000 < 200 then 
+          Atomicskiplist.add sl elems.(i) |> ignore
+        else if i mod 1000 >= 200 && i mod 1000 < 300 then 
+          Atomicskiplist.remove sl elems.(i) |> ignore
+        else 
+          Atomicskiplist.find sl elems.(i) |> ignore
+      )
+      done;
+      start_time
+    )) in 
+    let threads = List.init num_threads (fun _ -> push ()) in 
+    let start_time_threads = List.map (fun domain -> Domain.join domain) threads in 
+    let end_time = Unix.gettimeofday () in 
+    let time_diff = end_time -. (List.nth start_time_threads 0) in 
+    time_diff
+    
 
 
 let bench ~workload_type () =
   let workload =
     if workload_type = "read_heavy" then 
       read_heavy_workload
-    else
+    else if workload_type == "moderate_heavy" then 
+      moderate_heavy_workload
+    else 
       write_heavy_workload
     in
   let results = ref [] in

bench/main.ml

@@ -17,6 +17,7 @@ let benchmark_list =
     Mpmc_queue.bench ~use_cas:true ~takers:1 ~pushers:8;
     Mpmc_queue.bench ~use_cas:true ~takers:8 ~pushers:1;
     Bench_atomic_skiplist.bench ~workload_type:"read_heavy";
+    Bench_atomic_skiplist.bench ~workload_type:"moderate_heavy";
   ]
   @ backoff_benchmarks
 

src/atomicskiplist.ml

@@ -69,8 +69,8 @@ let compare_and_set_mark_ref (atomic, old_node, old_mark, node, mark) =
   *)
 let find_in (key, preds, succs, sl) =
   let head = sl.head in
-  let init level =
-    let prev = head in
+  let init prev level =
+    let prev = prev in
     let curr = get_ref prev.next.(level) in
     let succ, mark = get_mark_ref curr.next.(level) in
     (prev, curr, succ, mark)
@@ -90,17 +90,22 @@ let find_in (key, preds, succs, sl) =
       iterate (curr, succ, new_succ, mark, level)
     else (prev, curr)
   in
-  let rec update_arrays level =
-    let prev, curr, succ, mark = init level in
+  let rec update_arrays prev level =
+    let prev, curr, succ, mark = 
+      if level == max_height then 
+        init head level 
+      else
+        init prev level
+    in 
     let prev, curr = iterate (prev, curr, succ, mark, level) in
-    if prev == null_node && curr == null_node then update_arrays max_height
+    if prev == null_node && curr == null_node then update_arrays null_node max_height
     else (
       preds.(level) <- prev;
       succs.(level) <- curr;
-      if level > 0 then update_arrays (level - 1)
+      if level > 0 then update_arrays prev (level - 1)
       else curr.key == key)
   in
-  update_arrays max_height
+  update_arrays null_node max_height
 
 (** Adds a new key to the skiplist sl. *)
 let add sl key =