Initial

13 files changed, 674 insertions, 0 deletions

diff --git a/src/Benchmarks/BenchmarkUtils.hs b/src/Benchmarks/BenchmarkUtils.hs
new file mode 100644
index 0000000..4b9546c
--- /dev/null
+++ b/src/Benchmarks/BenchmarkUtils.hs
@@ -0,0 +1,107 @@
+-- | This is a module which contains some ad-hoc HTML combinators for use when
+-- benchmarking
+--
+{-# LANGUAGE OverloadedStrings, NoMonomorphismRestriction #-}
+module Benchmarks.BenchmarkUtils
+    ( Html
+    , toHtml
+
+    , tr
+    , td
+    , html
+    , head
+    , title
+    , body
+    , div
+    , h1
+    , h2
+    , p
+    , ol
+    , li
+    , table
+    , img
+    , id
+    ) where
+
+import Prelude hiding (div, head, id)
+import Text.Blaze
+import Text.Blaze.Internal
+
+type Html = Markup
+
+toHtml :: ToMarkup a => a -> Html
+toHtml = toMarkup
+
+tr :: Html  -- ^ Inner HTML.
+   -> Html  -- ^ Resulting HTML.
+tr = Parent "tr" "<tr" "</tr>"
+{-# INLINE tr #-}
+
+td :: Html  -- ^ Inner HTML.
+   -> Html  -- ^ Resulting HTML.
+td = Parent "td" "<td" "</td>"
+{-# INLINE td #-}
+
+html :: Html  -- ^ Inner HTML.
+     -> Html  -- ^ Resulting HTML.
+html = Parent "html" "<html" "</html>"
+{-# INLINE html #-}
+
+head :: Html  -- ^ Inner HTML.
+     -> Html  -- ^ Resulting HTML.
+head = Parent "head" "<head" "</head>"
+{-# INLINE head #-}
+
+title :: Html  -- ^ Inner HTML.
+      -> Html  -- ^ Resulting HTML.
+title = Parent "title" "<title" "</title>"
+{-# INLINE title #-}
+
+body :: Html  -- ^ Inner HTML.
+     -> Html  -- ^ Resulting HTML.
+body = Parent "body" "<body" "</body>"
+{-# INLINE body #-}
+
+div :: Html  -- ^ Inner HTML.
+    -> Html  -- ^ Resulting HTML.
+div = Parent "div" "<div" "</div>"
+{-# INLINE div #-}
+
+h1 :: Html  -- ^ Inner HTML.
+   -> Html  -- ^ Resulting HTML.
+h1 = Parent "h1" "<h1" "</h1>"
+{-# INLINE h1 #-}
+
+h2 :: Html  -- ^ Inner HTML.
+   -> Html  -- ^ Resulting HTML.
+h2 = Parent "h2" "<h2" "</h2>"
+{-# INLINE h2 #-}
+
+p :: Html  -- ^ Inner HTML.
+  -> Html  -- ^ Resulting HTML.
+p = Parent "p" "<p" "</p>"
+{-# INLINE p #-}
+
+ol :: Html  -- ^ Inner HTML.
+   -> Html  -- ^ Resulting HTML.
+ol = Parent "ol" "<ol" "</ol>"
+{-# INLINE ol #-}
+
+li :: Html  -- ^ Inner HTML.
+   -> Html  -- ^ Resulting HTML.
+li = Parent "li" "<li" "</li>"
+{-# INLINE li #-}
+
+table :: Html  -- ^ Inner HTML.
+      -> Html  -- ^ Resulting HTML.
+table = Parent "table" "<table" "</table>"
+{-# INLINE table #-}
+
+img :: Html  -- ^ Resulting HTML.
+img = Leaf "img" "<img" ">"
+{-# INLINE img #-}
+
+id :: AttributeValue  -- ^ Attribute value.
+   -> Attribute       -- ^ Resulting attribute.
+id = attribute "id" " id=\""
+{-# INLINE id #-}
diff --git a/src/Benchmarks/BlazeTBenchmarks.hs b/src/Benchmarks/BlazeTBenchmarks.hs
new file mode 100644
index 0000000..83a38ad
--- /dev/null
+++ b/src/Benchmarks/BlazeTBenchmarks.hs
@@ -0,0 +1,133 @@
+-- | This is a collection of HTML benchmarks for BlazeMarkup.
+--
+{-# LANGUAGE OverloadedStrings, ExistentialQuantification, RankNTypes #-}
+{-# OPTIONS_GHC -fno-warn-unused-do-bind #-}
+module Benchmarks.BlazeTBenchmarks where
+
+import           Data.Monoid (Monoid, mempty, mconcat, mappend)
+import           Prelude hiding (div, id,map)
+import qualified Prelude as P
+
+import           Text.BlazeT
+import           Text.BlazeT.Html5
+import qualified Text.BlazeT.Html5 as H
+import qualified Text.BlazeT.Html5.Attributes as A
+
+-- | Description of an HTML benchmark
+--
+data HtmlBenchmark = forall a. HtmlBenchmark
+    String       -- ^ Name.
+    (a -> Html)  -- ^ Rendering function.
+    a            -- ^ Data.
+    Html         -- ^ Longer description.
+
+-- | List containing all benchmarks.
+--
+benchmarks :: [HtmlBenchmark]
+benchmarks =
+    [ HtmlBenchmark "bigTable" bigTable bigTableData $
+        let h = toHtml $ length bigTableData
+            w = toHtml $ length $ P.head bigTableData
+        in (string "Rendering of a big (") >> h >> (string "x") >> w >> ") HTML table"
+    , HtmlBenchmark "basic" basic basicData
+        "A simple, small basic template with a few holes to fill in"
+    , HtmlBenchmark "wideTree" wideTree wideTreeData $
+        (string "A very wide tree (") >> toHtml (length wideTreeData) >> " elements)"
+    , HtmlBenchmark "wideTreeEscaping" wideTree wideTreeEscapingData $ do
+        (string "A very wide tree (") >> toHtml (length wideTreeData) >> (string " elements)")
+        " with lots of escaping"
+    , HtmlBenchmark "deepTree" deepTree deepTreeData $ do
+        (string "A really deep tree (") >> toHtml deepTreeData >> " nested templates)"
+    , HtmlBenchmark "manyAttributes" manyAttributes manyAttributesData $ do
+        (string "A single element with ") >> toHtml (length manyAttributesData)
+        " attributes."
+    , HtmlBenchmark "customAttribute" customAttributes customAttributesData $
+        "Creating custom attributes"
+    ]
+
+rows :: Int
+rows = 1000
+
+bigTableData :: [[Int]]
+bigTableData = replicate rows [1..10]
+{-# NOINLINE bigTableData #-}
+
+basicData :: (String, String, [String])
+basicData = ("Just a test", "joe", items)
+{-# NOINLINE basicData #-}
+
+items :: [String]
+items = fmap (("Number " `mappend`) . show) [1 :: Int .. 14]
+{-# NOINLINE items #-}
+
+wideTreeData :: [String]
+wideTreeData = take 5000 $
+    cycle ["λf.(λx.fxx)(λx.fxx)", "These old days", "Foobar", "lol", "x ∈ A"]
+{-# NOINLINE wideTreeData #-}
+
+wideTreeEscapingData :: [String]
+wideTreeEscapingData = take 1000 $
+    cycle ["<><>", "\"lol\"", "<&>", "'>>'"]
+{-# NOINLINE wideTreeEscapingData #-}
+
+deepTreeData :: Int
+deepTreeData = 1000
+{-# NOINLINE deepTreeData #-}
+
+manyAttributesData :: [String]
+manyAttributesData = wideTreeData
+
+customAttributesData :: [(String, String)]
+customAttributesData = zip wideTreeData wideTreeData
+
+-- | Render the argument matrix as an HTML table.
+--
+bigTable :: [[Int]]  -- ^ Matrix.
+         -> Html     -- ^ Result.
+bigTable t = table $ mconcat $ fmap row t
+  where
+    row r = tr $ mconcat $ fmap (td . toHtml) r
+
+-- | Render a simple HTML page with some data.
+--
+basic :: (String, String, [String])  -- ^ (Title, User, Items)
+      -> Html                        -- ^ Result.
+basic (title', user, items') = html $ do
+    H.head $ title $ toHtml title'
+    body $ do
+        div ! A.id "header" $ (h1 $ toHtml title')
+        p $ "Hello, " `mappend` toHtml user `mappend` "!"
+        p $ "Hello, me!"
+        p $ "Hello, world!"
+        h2 $ "loop"
+        ol $ mconcat $ fmap (li . toHtml) items'
+        div ! A.id "footer" $ mempty
+
+-- | A benchmark producing a very wide but very shallow tree.
+--
+wideTree :: [String]  -- ^ Text to create a tree from.
+         -> Html      -- ^ Result.
+wideTree = div . mapM_ ((p ! A.id "foo") . toHtml)
+
+-- | Create a very deep tree.
+--
+deepTree :: Int   -- ^ Depth of the tree.
+         -> Html  -- ^ Result.
+deepTree 0 = "foo"
+deepTree n = p $ table $ tr $ td $ div $ deepTree (n - 1)
+
+-- | Create an element with many attributes.
+--
+manyAttributes :: [String]  -- ^ List of attribute values.
+               -> Html      -- ^ Result.
+manyAttributes = foldl setAttribute img
+  where
+    setAttribute html' value' = html' ! A.id (toValue value')
+    {-# INLINE setAttribute #-}
+
+customAttributes :: [(String, String)]  -- ^ List of attribute name, value pairs
+                 -> Html                -- ^ Result
+customAttributes = foldl setAttribute img
+  where
+    setAttribute html' (name, value') =
+        html' ! customAttribute (stringTag name) (toValue value')
diff --git a/src/Benchmarks/HtmlBenchmarks.hs b/src/Benchmarks/HtmlBenchmarks.hs
new file mode 100644
index 0000000..3070d52
--- /dev/null
+++ b/src/Benchmarks/HtmlBenchmarks.hs
@@ -0,0 +1,132 @@
+-- | This is a collection of HTML benchmarks for BlazeMarkup.
+--
+{-# LANGUAGE OverloadedStrings, ExistentialQuantification #-}
+{-# OPTIONS_GHC -fno-warn-unused-do-bind #-}
+module Benchmarks.HtmlBenchmarks where
+
+import Data.Monoid (Monoid, mempty, mconcat, mappend)
+import Prelude hiding (div, id)
+import qualified Prelude as P
+
+import Benchmarks.BenchmarkUtils
+import Text.Blaze
+import qualified Benchmarks.BenchmarkUtils as H
+
+-- | Description of an HTML benchmark
+--
+data HtmlBenchmark = forall a. HtmlBenchmark
+    { hName :: String       -- ^ Name.
+    , hR :: (a -> Html)  -- ^ Rendering function.
+    , hD :: a            -- ^ Data.
+    , hH :: Html }         -- ^ Longer description.
+
+-- | List containing all benchmarks.
+--
+benchmarks :: [HtmlBenchmark]
+benchmarks =
+    [ HtmlBenchmark "bigTable" bigTable bigTableData $
+        let h = toHtml $ length bigTableData
+            w = toHtml $ length $ P.head bigTableData
+        in "Rendering of a big (" >> h >> "x" >> w >> ") HTML table"
+    , HtmlBenchmark "basic" basic basicData
+        "A simple, small basic template with a few holes to fill in"
+    , HtmlBenchmark "wideTree" wideTree wideTreeData $
+        "A very wide tree (" >> toHtml (length wideTreeData) >> " elements)"
+    , HtmlBenchmark "wideTreeEscaping" wideTree wideTreeEscapingData $ do
+        "A very wide tree (" >> toHtml (length wideTreeData) >> " elements)"
+        " with lots of escaping"
+    , HtmlBenchmark "deepTree" deepTree deepTreeData $ do
+        "A really deep tree (" >> toHtml deepTreeData >> " nested templates)"
+    , HtmlBenchmark "manyAttributes" manyAttributes manyAttributesData $ do
+        "A single element with " >> toHtml (length manyAttributesData)
+        " attributes."
+    , HtmlBenchmark "customAttribute" customAttributes customAttributesData $
+        "Creating custom attributes"
+    ]
+
+rows :: Int
+rows = 1000
+
+bigTableData :: [[Int]]
+bigTableData = replicate rows [1..10]
+{-# NOINLINE bigTableData #-}
+
+basicData :: (String, String, [String])
+basicData = ("Just a test", "joe", items)
+{-# NOINLINE basicData #-}
+
+items :: [String]
+items = map (("Number " `mappend`) . show) [1 :: Int .. 14]
+{-# NOINLINE items #-}
+
+wideTreeData :: [String]
+wideTreeData = take 5000 $
+    cycle ["λf.(λx.fxx)(λx.fxx)", "These old days", "Foobar", "lol", "x ∈ A"]
+{-# NOINLINE wideTreeData #-}
+
+wideTreeEscapingData :: [String]
+wideTreeEscapingData = take 1000 $
+    cycle ["<><>", "\"lol\"", "<&>", "'>>'"]
+{-# NOINLINE wideTreeEscapingData #-}
+
+deepTreeData :: Int
+deepTreeData = 1000
+{-# NOINLINE deepTreeData #-}
+
+manyAttributesData :: [String]
+manyAttributesData = wideTreeData
+
+customAttributesData :: [(String, String)]
+customAttributesData = zip wideTreeData wideTreeData
+
+-- | Render the argument matrix as an HTML table.
+--
+bigTable :: [[Int]]  -- ^ Matrix.
+         -> Html     -- ^ Result.
+bigTable t = table $ mconcat $ map row t
+  where
+    row r = tr $ mconcat $ map (td . toHtml) r
+
+-- | Render a simple HTML page with some data.
+--
+basic :: (String, String, [String])  -- ^ (Title, User, Items)
+      -> Html                        -- ^ Result.
+basic (title', user, items') = html $ do
+    H.head $ title $ toHtml title'
+    body $ do
+        div ! id "header" $ (h1 $ toHtml title')
+        p $ "Hello, " `mappend` toHtml user `mappend` "!"
+        p $ "Hello, me!"
+        p $ "Hello, world!"
+        h2 $ "loop"
+        ol $ mconcat $ map (li . toHtml) items'
+        div ! id "footer" $ mempty
+
+-- | A benchmark producing a very wide but very shallow tree.
+--
+wideTree :: [String]  -- ^ Text to create a tree from.
+         -> Html      -- ^ Result.
+wideTree = div . mapM_ ((p ! id "foo") . toHtml)
+
+-- | Create a very deep tree.
+--
+deepTree :: Int   -- ^ Depth of the tree.
+         -> Html  -- ^ Result.
+deepTree 0 = "foo"
+deepTree n = p $ table $ tr $ td $ div $ deepTree (n - 1)
+
+-- | Create an element with many attributes.
+--
+manyAttributes :: [String]  -- ^ List of attribute values.
+               -> Html      -- ^ Result.
+manyAttributes = foldl setAttribute img
+  where
+    setAttribute html' value' = html' ! id (toValue value')
+    {-# INLINE setAttribute #-}
+
+customAttributes :: [(String, String)]  -- ^ List of attribute name, value pairs
+                 -> Html                -- ^ Result
+customAttributes = foldl setAttribute img
+  where
+    setAttribute html' (name, value') =
+        html' ! customAttribute (stringTag name) (toValue value')
diff --git a/src/Benchmarks/LICENSE b/src/Benchmarks/LICENSE
new file mode 100644
index 0000000..8122505
--- /dev/null
+++ b/src/Benchmarks/LICENSE
@@ -0,0 +1,30 @@
+Copyright Jasper Van der Jeugt 2010
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+
+    * Redistributions in binary form must reproduce the above
+      copyright notice, this list of conditions and the following
+      disclaimer in the documentation and/or other materials provided
+      with the distribution.
+
+    * Neither the name of Jasper Van der Jeugt nor the names of other
+      contributors may be used to endorse or promote products derived
+      from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/src/Benchmarks/RunHtmlBenchmarks.hs b/src/Benchmarks/RunHtmlBenchmarks.hs
new file mode 100644
index 0000000..04c28ff
--- /dev/null
+++ b/src/Benchmarks/RunHtmlBenchmarks.hs
@@ -0,0 +1,36 @@
+-- | This is a module which runs the 'HtmlBenchmarks' module using the different
+-- renderers available.
+--
+module Benchmarks.RunHtmlBenchmarks where
+
+import Criterion.Main
+import qualified Data.Text.Lazy as LT
+import Data.List
+import qualified Data.ByteString.Lazy as LB
+
+import qualified Text.Blaze.Renderer.Utf8 as Utf8
+import qualified Text.Blaze.Renderer.String as String
+import qualified Text.Blaze.Renderer.Text as Text
+
+import Benchmarks.HtmlBenchmarks (HtmlBenchmark (..), benchmarks)
+import qualified Benchmarks.BlazeTBenchmarks as BT (HtmlBenchmark (..), benchmarks)
+import qualified Text.BlazeT.Renderer.Utf8 as TUtf8
+import qualified Text.BlazeT.Renderer.String as TString
+import qualified Text.BlazeT.Renderer.Text as TText
+
+-- | Function to run the benchmarks using criterion
+--
+main :: IO ()
+main = defaultMain $ zipWith g benchmarks BT.benchmarks
+  where
+    g x y = bgroup (hName x) $ benchHtml x ++ benchHtml2 y
+    benchHtml  (HtmlBenchmark _ f x _) = 
+        [ bench "Utf8"   $ nf (LB.length .  Utf8.renderMarkup . f) x
+        , bench "String" $ nf (String.renderMarkup . f) x
+        , bench "Text"   $ nf (LT.length . Text.renderMarkup . f) x
+        ]
+    benchHtml2 (BT.HtmlBenchmark _ f x _) =
+        [ bench "BlazeT.Utf8"   $ nf (LB.length .  TUtf8.renderMarkup . f) x
+        , bench "BlazeT.String" $ nf (TString.renderMarkup . f) x
+        , bench "BlazeT.Text"   $ nf (LT.length . TText.renderMarkup . f) x
+        ]
diff --git a/src/Benchmarks/ServerChunkSize.hs b/src/Benchmarks/ServerChunkSize.hs
new file mode 100644
index 0000000..7b01c68
--- /dev/null
+++ b/src/Benchmarks/ServerChunkSize.hs
@@ -0,0 +1,52 @@
+-- | A benchmark for measuring the impact of lazy bytestring chunk size on
+-- server performance.
+--
+{-# LANGUAGE OverloadedStrings #-}
+module Main where
+
+import Control.Concurrent (forkIO)
+import Control.Monad (forever)
+import Data.Monoid (mappend)
+import Network (listenOn, PortID (PortNumber))
+import Network.Socket (accept, sClose)
+import Prelude hiding (putStrLn)
+import System.Environment (getArgs)
+
+import Network.Socket.ByteString (recv, send)
+import Network.Socket.ByteString.Lazy (sendAll)
+import qualified Data.ByteString.Char8 as SBC
+import qualified Data.ByteString.Lazy as LB
+
+-- | Generate a 128k response, with a given chunk size.
+--
+makeResponse :: Int            -- ^ Chunk size.
+             -> LB.ByteString  -- ^ Result.
+makeResponse chunkSize =
+    let chunks = createChunks chunkSize totalSize
+    in LB.fromChunks chunks
+  where
+    -- A 64 kilobyte response.
+    totalSize = 128 * 1024
+
+    createChunks c s
+      | c < s     = SBC.replicate c 'a' : createChunks c (s - c)
+      | otherwise = SBC.replicate s 'a' : []
+
+main :: IO ()
+main = do
+    args <- getArgs
+    let port = PortNumber $ fromIntegral $ (read $ head args :: Int)
+        chunkSize = read $ args !! 1
+
+    socket <- listenOn port
+    forever $ do
+        (s, _) <- accept socket
+        forkIO (respond chunkSize s)
+  where
+    respond chunkSize s = do
+        _ <- recv s 1024
+        _ <- send s $ "HTTP/1.1 200 OK\r\n"
+            `mappend` "Content-Type: text/html; charset=UTF-8\r\n"
+            `mappend` "\r\n"
+        sendAll s $ makeResponse chunkSize
+        sClose s
diff --git a/src/Benchmarks/bigtable/erb.rb b/src/Benchmarks/bigtable/erb.rb
new file mode 100644
index 0000000..c3a675a
--- /dev/null
+++ b/src/Benchmarks/bigtable/erb.rb
@@ -0,0 +1,32 @@
+# BigTable benchmark implemented in ERB.
+#
+require 'erb'
+require 'benchmark'
+include ERB::Util
+
+table = (1 .. 1000).map do |_| (1 .. 10) end
+
+template = ERB.new <<-EOF
+<table>
+  <% table.each do |row| %>
+    <tr>
+      <% row.each do |value| %>
+        <td>
+            <%= value %>
+        </td>
+      <% end %>
+    </tr>
+  <% end %>
+</table>
+EOF
+
+number_runs = 100
+start_time = Time.now.to_f
+number_runs.times do
+    template.result(binding)
+end
+end_time = Time.now.to_f
+
+# start_time and end_time are both in seconds now
+ms = (end_time - start_time) * 1000 / number_runs
+puts "\"ERB\", #{ms}"
diff --git a/src/Benchmarks/bigtable/erubis.rb b/src/Benchmarks/bigtable/erubis.rb
new file mode 100644
index 0000000..9a1edf9
--- /dev/null
+++ b/src/Benchmarks/bigtable/erubis.rb
@@ -0,0 +1,31 @@
+# BigTable benchmark implemented in erubis
+#
+require 'erubis'
+require 'benchmark'
+
+table = (1 .. 1000).map do |_| (1 .. 10) end
+
+template = Erubis::Eruby.new <<-EOF
+<table>
+  <% table.each do |row| %>
+    <tr>
+      <% row.each do |value| %>
+        <td>
+            <%= value %>
+        </td>
+      <% end %>
+    </tr>
+  <% end %>
+</table>
+EOF
+
+number_runs = 100
+start_time = Time.now.to_f
+number_runs.times do
+    template.result(binding)
+end
+end_time = Time.now.to_f
+
+# start_time and end_time are both in seconds now
+ms = (end_time - start_time) * 1000 / number_runs
+puts "\"Erubis\", #{ms}"
diff --git a/src/Benchmarks/bigtable/hamlet.hs b/src/Benchmarks/bigtable/hamlet.hs
new file mode 100644
index 0000000..2778f2d
--- /dev/null
+++ b/src/Benchmarks/bigtable/hamlet.hs
@@ -0,0 +1,33 @@
+-- | BigTable benchmark implemented using Hamlet.
+--
+{-# LANGUAGE QuasiQuotes #-}
+module Main where
+
+import Criterion.Main
+import Text.Hamlet
+import Text.Hamlet.Monad
+import Numeric (showInt)
+import Data.Text (Text)
+import qualified Data.Text as T
+import Data.Maybe (fromJust)
+
+main = defaultMain
+    [ bench "bigTable" $ nf bigTable bigTableData
+    ]
+  where
+    rows :: Int
+    rows = 1000
+
+    bigTableData :: [[Int]]
+    bigTableData = replicate rows [1..10]
+    {-# NOINLINE bigTableData #-}
+
+bigTable rows = fromJust $ hamletToText undefined [$hamlet|
+%table
+    $forall rows row
+        %tr
+            $forall row cell
+                %td $showInt'.cell$
+|]
+  where
+    showInt' i = Encoded $ T.pack $ showInt i ""
diff --git a/src/Benchmarks/bigtable/html-minimalist.hs b/src/Benchmarks/bigtable/html-minimalist.hs
new file mode 100644
index 0000000..2a52751
--- /dev/null
+++ b/src/Benchmarks/bigtable/html-minimalist.hs
@@ -0,0 +1,20 @@
+-- | BigTable benchmark using the html-minimalist package from hackage.
+--
+import Text.HTML.Light hiding (map)
+import Criterion.Main
+
+bigTable :: [[Int]] -> String
+bigTable t =
+    renderXHTML xhtml_1_0_strict $ html [] $ return $ table [] $ map row t
+  where
+    row r = tr [] $ map (td [] . return . cdata . show) r
+
+main = defaultMain
+    [ bench "bigTable" $ nf bigTable myTable ]
+  where
+    rows :: Int
+    rows = 1000
+
+    myTable :: [[Int]]
+    myTable = replicate rows [1..10]
+    {-# NOINLINE myTable #-}
diff --git a/src/Benchmarks/bigtable/html.hs b/src/Benchmarks/bigtable/html.hs
new file mode 100644
index 0000000..57a62b3
--- /dev/null
+++ b/src/Benchmarks/bigtable/html.hs
@@ -0,0 +1,19 @@
+-- | BigTable benchmark using the HTML package from hackage.
+--
+import Text.Html
+import Criterion.Main
+
+bigTable :: [[Int]] -> String
+bigTable t = renderHtml $ table $ concatHtml $ map row t
+  where
+    row r = tr $ concatHtml $ map (td . stringToHtml . show) r
+
+main = defaultMain
+    [ bench "bigTable" $ nf bigTable myTable ]
+  where
+    rows :: Int
+    rows = 1000
+
+    myTable :: [[Int]]
+    myTable = replicate rows [1..10]
+    {-# NOINLINE myTable #-}
diff --git a/src/Benchmarks/bigtable/php.php b/src/Benchmarks/bigtable/php.php
new file mode 100644
index 0000000..f2e51a4
--- /dev/null
+++ b/src/Benchmarks/bigtable/php.php
@@ -0,0 +1,30 @@
+<?php
+$table = array_fill(0, 1000, array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10));
+
+function test_bigtable($table) {
+        ob_start();
+?>
+<table>
+<?php foreach($table as $row) { ?>
+<tr>
+<?php foreach($row as $value) { ?>
+<td><?php echo $value; ?></td>
+<?php } ?>
+</tr>
+<?php } ?>
+</table>
+<?php
+        return ob_get_clean();
+}
+
+$request_count = 1000;
+
+$start = microtime(true);
+for ($i = 0; $i < $request_count; $i++)
+{
+  test_bigtable($table);
+}
+$elapsed = microtime(true) - $start;
+$time_per_request = ($elapsed / $request_count) * 1000;
+echo "\"PHP\", $time_per_request\n";
+?>
diff --git a/src/Benchmarks/bigtable/xhtml.hs b/src/Benchmarks/bigtable/xhtml.hs
new file mode 100644
index 0000000..993994c
--- /dev/null
+++ b/src/Benchmarks/bigtable/xhtml.hs
@@ -0,0 +1,19 @@
+-- | BigTable benchmark using the XHTML package from hackage.
+--
+import Text.XHtml.Strict
+import Criterion.Main
+
+bigTable :: [[Int]] -> String
+bigTable t = renderHtml $ table $ concatHtml $ map row t
+  where
+    row r = tr $ concatHtml $ map (td . stringToHtml . show) r
+
+main = defaultMain
+    [ bench "bigTable" $ nf bigTable myTable ]
+  where
+    rows :: Int
+    rows = 1000
+
+    myTable :: [[Int]]
+    myTable = replicate rows [1..10]
+    {-# NOINLINE myTable #-}