delete deques

awkward-squad · Jan 10, 2024 · a218afa · a218afa
1 parent cb5defe
commit a218afa
Show file tree

Hide file tree

Showing 7 changed files with 11 additions and 676 deletions.
diff --git a/bench/amortized-deque/Main.hs b/bench/amortized-deque/Main.hs
diff --git a/bench/real-time-deque/Main.hs b/bench/real-time-deque/Main.hs
diff --git a/queues.cabal b/queues.cabal
@@ -10,17 +10,17 @@ license-file: LICENSE
 maintainer: Mitchell Rosen <mitchellwrosen@gmail.com>, Travis Staton <hello@travisstaton.com>
 name: queues
 stability: experimental
-synopsis: Queue and deque data structures.
+synopsis: Queue data structures.
 tested-with: GHC == 9.4.7, GHC == 9.6.3, GHC == 9.8.1
 version: 0.1.0
 
 description:
-  Queue and deque data structures, as described in
+  Queue data structures, as described in
   .
     * Okasaki, Chris. "Simple and efficient purely functional queues and deques." /Journal of functional programming/ 5.4 (1995): 583-592.
     * Okasaki, Chris. /Purely Functional Data Structures/. Diss. Princeton University, 1996.
   .
-  This package provides two queue variants and one deque, whose salient API differences are summarized in the following table:
+  This package provides two queue variants, whose salient API differences are summarized in the following table:
   .
   +-----------------+----------------------+--------------------+
   |                 | @"EphemeralQueue"@   | @"Queue"@          |
@@ -29,13 +29,8 @@ description:
   +-----------------+----------------------+--------------------+
   | @dequeue@       | \(\mathcal{O}(1)^⧧\) | \(\mathcal{O}(1)\) |
   +-----------------+----------------------+--------------------+
-  | @length@        | \(\mathcal{O}(n)\)   | \(\mathcal{O}(n)\) |
-  +-----------------+----------------------+--------------------+
-  | @fromList@      | \(\mathcal{O}(1)\)   | \(\mathcal{O}(1)\) |
-  +-----------------+----------------------+--------------------+
   .
-    * \(^*\) Amortized.
-    * \(^⧧\) Amortized under ephemeral usage only.
+    * \(^*\) Amortized, under ephemeral usage only.
   .
   To see a rough performance comparison between the data structures, click into an individual module. Always benchmark
   your own code for accurate numbers.
@@ -93,8 +88,6 @@ library
   build-depends:
     base ^>= 4.17 || ^>= 4.18 || ^>= 4.19,
   exposed-modules:
-    Deque
-    Deque.RealTime
     Queue
     Queue.Ephemeral
   hs-source-dirs: src
@@ -111,17 +104,6 @@ test-suite test
   main-is: Main.hs
   type: exitcode-stdio-1.0
 
-benchmark bench-amortized-deque
-  import: component
-  build-depends:
-    base,
-    queues,
-    tasty-bench ^>= 0.3.5,
-  ghc-options: -fproc-alignment=64 -rtsopts -threaded
-  hs-source-dirs: bench/amortized-deque
-  main-is: Main.hs
-  type: exitcode-stdio-1.0
-
 benchmark bench-ephemeral-queue
   import: component
   build-depends:
@@ -133,17 +115,6 @@ benchmark bench-ephemeral-queue
   main-is: Main.hs
   type: exitcode-stdio-1.0
 
-benchmark bench-real-time-deque
-  import: component
-  build-depends:
-    base,
-    queues,
-    tasty-bench ^>= 0.3.5,
-  ghc-options: -fproc-alignment=64 -rtsopts -threaded
-  hs-source-dirs: bench/real-time-deque
-  main-is: Main.hs
-  type: exitcode-stdio-1.0
-
 benchmark bench-real-time-queue
   import: component
   build-depends:

diff --git a/scripts/run-benchmarks.hs b/scripts/run-benchmarks.hs
@@ -20,9 +20,7 @@ import System.Process qualified as Process
 import Text.Printf (printf)
 
 data Results = Results
-  { amortizedDeque :: !Result,
-    ephemeralQueue :: !Result,
-    realTimeDeque :: !Result,
+  { ephemeralQueue :: !Result,
     realTimeQueue :: !Result,
     sequenceQueue :: !Result
   }
@@ -40,9 +38,7 @@ main :: IO ()
 main = do
   Process.callCommand "cabal build --enable-benchmarks all"
 
-  amortizedDequeBenchmark <- List.init <$> Process.readProcess "cabal" ["list-bin", "bench-amortized-deque"] ""
   ephemeralQueueBenchmark <- List.init <$> Process.readProcess "cabal" ["list-bin", "bench-ephemeral-queue"] ""
-  realTimeDequeBenchmark <- List.init <$> Process.readProcess "cabal" ["list-bin", "bench-real-time-deque"] ""
   realTimeQueueBenchmark <- List.init <$> Process.readProcess "cabal" ["list-bin", "bench-real-time-queue"] ""
   sequenceQueueBenchmark <- List.init <$> Process.readProcess "cabal" ["list-bin", "bench-sequence-queue"] ""
 
@@ -64,21 +60,11 @@ main = do
           ]
         readCsv "results.csv"
 
-  let runAmortizedDequeBenchmark :: Results -> IO Results
-      runAmortizedDequeBenchmark results = do
-        result <- runBenchmark amortizedDequeBenchmark
-        pure $! results {amortizedDeque = amortizedDeque results <> result}
-
   let runEphemeralQueueBenchmark :: Results -> IO Results
       runEphemeralQueueBenchmark results = do
         result <- runBenchmark ephemeralQueueBenchmark
         pure $! results {ephemeralQueue = ephemeralQueue results <> result}
 
-  let runRealTimeDequeBenchmark :: Results -> IO Results
-      runRealTimeDequeBenchmark results = do
-        result <- runBenchmark realTimeDequeBenchmark
-        pure $! results {realTimeDeque = realTimeDeque results <> result}
-
   let runRealTimeQueueBenchmark :: Results -> IO Results
       runRealTimeQueueBenchmark results = do
         result <- runBenchmark realTimeQueueBenchmark
@@ -92,9 +78,7 @@ main = do
   let runBenchmarks :: [Results -> IO Results]
       runBenchmarks =
         cycle
-          [ runAmortizedDequeBenchmark,
-            runEphemeralQueueBenchmark,
-            runRealTimeDequeBenchmark,
+          [ runEphemeralQueueBenchmark,
             runRealTimeQueueBenchmark,
             runSequenceQueueBenchmark
           ]
@@ -104,21 +88,17 @@ main = do
         renderResults results1
         go results1 benches
 
-  go (Results mempty mempty mempty mempty mempty) runBenchmarks
+  go (Results mempty mempty mempty) runBenchmarks
 
 renderResults :: Results -> IO ()
 renderResults
   Results
-    { amortizedDeque = Result amortizedDequeRuns amortizedDequeTime0 amortizedDequeMem0,
-      ephemeralQueue = Result ephemeralQueueRuns ephemeralQueueTime0 ephemeralQueueMem0,
-      realTimeDeque = Result realTimeDequeRuns realTimeDequeTime0 realTimeDequeMem0,
+    { ephemeralQueue = Result ephemeralQueueRuns ephemeralQueueTime0 ephemeralQueueMem0,
       realTimeQueue = Result realTimeQueueRuns realTimeQueueTime0 realTimeQueueMem0,
       sequenceQueue = Result sequenceQueueRuns sequenceQueueTime0 sequenceQueueMem0
     } = do
-    let amortizedDequeInfo, ephemeralQueueInfo, realTimeDequeInfo, realTimeQueueInfo, sequenceQueueInfo :: (Text.Builder, Double, Double, Double)
-        amortizedDequeInfo = ("Deque", amortizedDequeRuns, amortizedDequeTime0 / amortizedDequeRuns, amortizedDequeMem0 / amortizedDequeRuns)
+    let ephemeralQueueInfo, realTimeQueueInfo, sequenceQueueInfo :: (Text.Builder, Double, Double, Double)
         ephemeralQueueInfo = ("Queue.Ephemeral", ephemeralQueueRuns, ephemeralQueueTime0 / ephemeralQueueRuns, ephemeralQueueMem0 / ephemeralQueueRuns)
-        realTimeDequeInfo = ("Deque.RealTime", realTimeDequeRuns, realTimeDequeTime0 / realTimeDequeRuns, realTimeDequeMem0 / realTimeDequeRuns)
         realTimeQueueInfo = ("Queue", realTimeQueueRuns, realTimeQueueTime0 / realTimeQueueRuns, realTimeQueueMem0 / realTimeQueueRuns)
         sequenceQueueInfo = ("Seq", sequenceQueueRuns, sequenceQueueTime0 / sequenceQueueRuns, sequenceQueueMem0 / sequenceQueueRuns)
 
@@ -138,27 +118,11 @@ renderResults
     (ByteString.putStr . Text.Builder.runBuilderBS) $
       Text.Builder.fromText (Text.replicate 80 "=")
         <> newline
-        <> renderComparison ephemeralQueueInfo amortizedDequeInfo
-        <> renderComparison realTimeDequeInfo amortizedDequeInfo
-        <> renderComparison realTimeQueueInfo amortizedDequeInfo
-        <> renderComparison sequenceQueueInfo amortizedDequeInfo
-        <> Text.Builder.fromText (Text.replicate 40 "-")
-        <> newline
-        <> renderComparison amortizedDequeInfo ephemeralQueueInfo
-        <> renderComparison realTimeDequeInfo ephemeralQueueInfo
         <> renderComparison realTimeQueueInfo ephemeralQueueInfo
         <> renderComparison sequenceQueueInfo ephemeralQueueInfo
         <> Text.Builder.fromText (Text.replicate 40 "-")
         <> newline
-        <> renderComparison amortizedDequeInfo realTimeDequeInfo
-        <> renderComparison ephemeralQueueInfo realTimeDequeInfo
-        <> renderComparison realTimeQueueInfo realTimeDequeInfo
-        <> renderComparison sequenceQueueInfo realTimeDequeInfo
-        <> Text.Builder.fromText (Text.replicate 40 "-")
-        <> newline
-        <> renderComparison amortizedDequeInfo realTimeQueueInfo
         <> renderComparison ephemeralQueueInfo realTimeQueueInfo
-        <> renderComparison realTimeDequeInfo realTimeQueueInfo
         <> renderComparison sequenceQueueInfo realTimeQueueInfo
     where
       newline = Text.Builder.fromChar '\n'