git.squeep.com Git - akkoma/blob - benchmarks/mix/tasks/pleroma/benchmarks/tags.ex

   1 defmodule Mix.Tasks.Pleroma.Benchmarks.Tags do
   2   use Mix.Task
   3
   4   import Pleroma.LoadTesting.Helper, only: [clean_tables: 0]
   5   import Ecto.Query
   6
   7   alias Pleroma.Repo
   8   alias Pleroma.Web.MastodonAPI.TimelineController
   9
  10   def run(_args) do
  11     Mix.Pleroma.start_pleroma()
  12     activities_count = Repo.aggregate(from(a in Pleroma.Activity), :count, :id)
  13
  14     if activities_count == 0 do
  15       IO.puts("Did not find any activities, cleaning and generating")
  16       clean_tables()
  17       Pleroma.LoadTesting.Users.generate_users(10)
  18       Pleroma.LoadTesting.Activities.generate_tagged_activities()
  19     else
  20       IO.puts("Found #{activities_count} activities, won't generate new ones")
  21     end
  22
  23     tags = Enum.map(0..20, fn i -> {"For #tag_#{i}", "tag_#{i}"} end)
  24
  25     Enum.each(tags, fn {_, tag} ->
  26       query =
  27         from(o in Pleroma.Object,
  28           where: fragment("(?)->'tag' \\? (?)", o.data, ^tag)
  29         )
  30
  31       count = Repo.aggregate(query, :count, :id)
  32       IO.puts("Database contains #{count} posts tagged with #{tag}")
  33     end)
  34
  35     user = Repo.all(Pleroma.User) |> List.first()
  36
  37     Benchee.run(
  38       %{
  39         "Hashtag fetching, any" => fn tags ->
  40           TimelineController.hashtag_fetching(
  41             %{
  42               "any" => tags
  43             },
  44             user,
  45             false
  46           )
  47         end,
  48         # Will always return zero results because no overlapping hashtags are generated.
  49         "Hashtag fetching, all" => fn tags ->
  50           TimelineController.hashtag_fetching(
  51             %{
  52               "all" => tags
  53             },
  54             user,
  55             false
  56           )
  57         end
  58       },
  59       inputs:
  60         tags
  61         |> Enum.map(fn {_, v} -> v end)
  62         |> Enum.chunk_every(2)
  63         |> Enum.map(fn tags -> {"For #{inspect(tags)}", tags} end),
  64       time: 5
  65     )
  66
  67     Benchee.run(
  68       %{
  69         "Hashtag fetching" => fn tag ->
  70           TimelineController.hashtag_fetching(
  71             %{
  72               "tag" => tag
  73             },
  74             user,
  75             false
  76           )
  77         end
  78       },
  79       inputs: tags,
  80       time: 5
  81     )
  82   end
  83 end