DO NOT MERGE, this is just a prototype as a base for discussion.

Progress towards #2525.

The basic idea is to replace a lot of scattered scoring logic (which
might become more complex) with encoding enough information in the rank
cache.

The information is encoded in a sort key that can be sorted
descendingly. The sort key is a tuple (serialized as string into the
database) of fixed precision decimals. Each tuple is using 9 decimals
and left padded with `0`s, so it's sortable via normal DB query
operations. If sorted ascending (e.g. penalty time), then we subtract
from a very large number.

For example, with ICPC scoring, the top 2 teams from NWERC 2024 gets
these sort keys:
```
00000000000000000000013.000000000,999999999999999999998725.000000000,999999999999999999999711.000000000
00000000000000000000011.000000000,999999999999999999998918.000000000,999999999999999999999701.000000000
```

With this mechanism, we should be able to implement other planned
scoring methods (in particular partial scoring, optimization problems)
without too much complication on the business logic side.

We do use `bcmath` with fixed precision to not run into numerical
precision issues with sequencing floating point operations. This is not
important today, but will become important once we deall with
non-integers (e.g. for optimization problems).

It also caches some computation and makes scoreboard computation more
efficient today.

Author: meisterT

.github/jobs/baseinstall.sh

@@ -15,6 +15,17 @@ MYSQL_ROOT_PASSWORD=${MYSQL_ROOT_PASSWORD:-root}
 
 set -euxo pipefail
 
+sudo apt update && sudo apt install php-bcmath -y
+sudo apt install php${phpversion}-bcmath -y
+
+echo
+echo "DEBUG <========================================================================="
+echo
+apt search bcmath
+echo "DEBUG <========================================================================="
+echo
+
+
 if [ -z "$phpversion" ]; then
 phpversion=$(php -r 'echo PHP_MAJOR_VERSION.".".PHP_MINOR_VERSION."\n";')
 fi

.github/workflows/codeql-analysis.yml

@@ -36,6 +36,9 @@ jobs:
       with:
         languages: ${{ matrix.language }}
 
+    - name: Install bcmath
+      run: sudo apt update; sudo apt install php-bcmath -y
+
     - name: Install composer files
       if: ${{ contains(env.COMPILED, matrix.language) }}
       run: |

doc/manual/install-domserver.rst

@@ -37,14 +37,14 @@ GNU/Linux, or one of its derivative distributions like Ubuntu::
 
   sudo apt install libcgroup-dev make acl zip unzip pv mariadb-server apache2 \
         php php-fpm php-gd php-cli php-intl php-mbstring php-mysql \
-        php-curl php-json php-xml php-zip composer ntp python3-yaml
+        php-curl php-json php-xml php-zip composer ntp python3-yaml php-bcmath
 
 The following command can be used on Fedora, and related distributions like
 Red Hat Enterprise Linux and Rocky Linux (before V9)::
 
   sudo dnf install libcgroup-devel make acl zip unzip pv mariadb-server httpd \
         php-gd php-cli php-intl php-mbstring php-mysqlnd php-fpm \
-        php-xml php-zip composer chronyd python3-pyyaml
+        php-xml php-zip composer chronyd python3-pyyaml php-bcmath
 
 `nginx` can be used as an alternate web server.
 

webapp/composer.json

@@ -40,6 +40,7 @@
 	],
 	"require": {
 		"php": "^8.1.0",
+		"ext-bcmath": "*",
 		"ext-ctype": "*",
 		"ext-curl": "*",
 		"ext-fileinfo": "*",

webapp/composer.lock

@@ -0,0 +1,40 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DoctrineMigrations;
+
+use Doctrine\DBAL\Schema\Schema;
+use Doctrine\Migrations\AbstractMigration;
+
+/**
+ * Auto-generated Migration: Please modify to your needs!
+ */
+final class Version20250309122806 extends AbstractMigration
+{
+    public function getDescription(): string
+    {
+        return 'Add sort keys to rankcache, allowing us to support different scoring functions efficiently and elegantly';
+    }
+
+    public function up(Schema $schema): void
+    {
+        // this up() migration is auto-generated, please modify it to your needs
+        $this->addSql('ALTER TABLE rankcache ADD sort_key_public TEXT DEFAULT \'\' NOT NULL COMMENT \'Opaque sort key for public audience.\', ADD sort_key_restricted TEXT DEFAULT \'\' NOT NULL COMMENT \'Opaque sort key for restricted audience.\'');
+        $this->addSql('CREATE INDEX sortKeyPublic ON rankcache (sort_key_public)');
+        $this->addSql('CREATE INDEX sortKeyRestricted ON rankcache (sort_key_restricted)');
+    }
+
+    public function down(Schema $schema): void
+    {
+        // this down() migration is auto-generated, please modify it to your needs
+        $this->addSql('DROP INDEX sortKeyPublic ON rankcache');
+        $this->addSql('DROP INDEX sortKeyRestricted ON rankcache');
+        $this->addSql('ALTER TABLE rankcache DROP sort_key_public, DROP sort_key_restricted');
+    }
+
+    public function isTransactional(): bool
+    {
+        return false;
+    }
+}

webapp/migrations/Version20250309122806.php

@@ -412,7 +412,7 @@ protected function getResultsHtml(
         $filter           = new Filter();
         $filter->categories = $categoryIds;
         $scoreboard = $this->scoreboardService->getScoreboard($contest, true, $filter);
-        $teams      = $scoreboard->getTeams();
+        $teams      = $scoreboard->getTeamsInDescendingOrder();
 
         $teamNames = [];
         foreach ($teams as $team) {

webapp/src/Controller/Jury/ImportExportController.php

@@ -22,13 +22,13 @@ public function load(ObjectManager $manager): void
 
         $manager->persist($team2);
 
+        $contest = $manager->getRepository(Contest::class)->findOneBy(['shortname' => 'demo']);
         $submissionData = [
             // team, submittime,            result]
-            [$team1, '2021-01-01 12:34:56', 'correct'],
-            [$team2, '2021-01-01 12:33:56', 'wrong-answer'],
+            [$team1, $contest->getStarttime() + 400, 'correct'],
+            [$team2, $contest->getStarttime() + 300, 'wrong-answer'],
         ];
 
-        $contest = $manager->getRepository(Contest::class)->findOneBy(['shortname' => 'demo']);
         $language = $manager->getRepository(Language::class)->find('cpp');
         $problem = $contest->getProblems()->filter(fn(ContestProblem $problem) => $problem->getShortname() === 'A')->first();
 
@@ -39,11 +39,11 @@ public function load(ObjectManager $manager): void
                 ->setContestProblem($problem)
                 ->setLanguage($language)
                 ->setValid(true)
-                ->setSubmittime(Utils::toEpochFloat($submissionItem[1]));
+                ->setSubmittime($submissionItem[1]);
             $judging = (new Judging())
                 ->setContest($contest)
-                ->setStarttime(Utils::toEpochFloat($submissionItem[1]))
-                ->setEndtime(Utils::toEpochFloat($submissionItem[1]) + 5)
+                ->setStarttime($submissionItem[1])
+                ->setEndtime($submissionItem[1] + 5)
                 ->setValid(true)
                 ->setResult($submissionItem[2]);
             $judging->setSubmission($submission);

webapp/src/DataFixtures/Test/RejudgingFirstToSolveFixture.php

@@ -1,6 +1,7 @@
 <?php declare(strict_types=1);
 namespace App\Entity;
 
+use Doctrine\DBAL\Platforms\AbstractMySQLPlatform;
 use Doctrine\ORM\Mapping as ORM;
 
 /**
@@ -18,6 +19,8 @@
 #[ORM\Index(columns: ['cid', 'points_public', 'totaltime_public', 'totalruntime_public'], name: 'order_public')]
 #[ORM\Index(columns: ['cid'], name: 'cid')]
 #[ORM\Index(columns: ['teamid'], name: 'teamid')]
+#[ORM\Index(columns: ['sort_key_public'], name: 'sortKeyPublic')]
+#[ORM\Index(columns: ['sort_key_restricted'], name: 'sortKeyRestricted')]
 class RankCache
 {
     #[ORM\Column(options: [
@@ -62,6 +65,20 @@ class RankCache
     #[ORM\JoinColumn(name: 'teamid', referencedColumnName: 'teamid', onDelete: 'CASCADE')]
     private Team $team;
 
+    #[ORM\Column(
+        type: 'text',
+        length: AbstractMySQLPlatform::LENGTH_LIMIT_TEXT,
+        options: ['comment' => 'Opaque sort key for public audience.', 'default' => '']
+    )]
+    private string $sortKeyPublic = '';
+
+    #[ORM\Column(
+        type: 'text',
+        length: AbstractMySQLPlatform::LENGTH_LIMIT_TEXT,
+        options: ['comment' => 'Opaque sort key for restricted audience.', 'default' => '']
+    )]
+    private string $sortKeyRestricted = '';
+
     public function setPointsRestricted(int $pointsRestricted): RankCache
     {
         $this->points_restricted = $pointsRestricted;
@@ -149,4 +166,26 @@ public function getTeam(): Team
     {
         return $this->team;
     }
+
+    public function setSortKeyPublic(string $sortKeyPublic): RankCache
+    {
+        $this->sortKeyPublic = $sortKeyPublic;
+        return $this;
+    }
+
+    public function getSortKeyPublic(): string
+    {
+        return $this->sortKeyPublic;
+    }
+
+    public function setSortKeyRestricted(string $sortKeyRestricted): RankCache
+    {
+        $this->sortKeyRestricted = $sortKeyRestricted;
+        return $this;
+    }
+
+    public function getSortKeyRestricted(): string
+    {
+        return $this->sortKeyRestricted;
+    }
 }

webapp/src/Entity/RankCache.php

@@ -16,7 +16,7 @@ protected function loadAwards(Contest $contest, Scoreboard $scoreboard): void
     {
         $group_winners = $problem_winners = $problem_shortname = [];
         $groups = [];
-        foreach ($scoreboard->getTeams() as $team) {
+        foreach ($scoreboard->getTeamsInDescendingOrder() as $team) {
             $teamid = $team->getExternalid();
             if ($scoreboard->isBestInCategory($team)) {
                 $catId = $team->getCategory()->getExternalid();