refactor scoreboard: replace threads-config.yml with points-info.yml; extend scoring with reports section

Author: allnes

scoreboard/README.md

@@ -16,7 +16,7 @@ Generates `output_directory/index.html` with the scoreboard.
 
 ## Configuration
 
-- `data/threads-config.yml` - Task points, deadlines, penalties
+- `data/points-info.yml` - Task points, deadlines, penalties
 - `data/plagiarism.yml` - Flagged submissions
 
 ## Testing

scoreboard/assign_variant.py

@@ -0,0 +1,141 @@
+# file: assign_variant.py
+"""
+Deterministic variant assignment from Full Name + Group
+with the repository name as the ONLY salt.
+
+Algorithm:
+  1) Normalize strings (NFKC, trim, lowercase, map 'ё'->'е', collapse spaces).
+  2) Build a key: "surname|name|patronymic|group|repo".
+  3) SHA-256(key) -> big integer -> modulo `num_variants`.
+
+Properties:
+- Stable: same inputs → same output.
+- Uniform: modulo of a cryptographic hash distributes evenly.
+- Note: Without the full group roster, zero collisions cannot be *guaranteed*
+  (birthday paradox). This is intended for “approximately unique” per-group use.
+
+Usage:
+    from assign_variant import assign_variant
+    v = assign_variant(
+        surname="Petrov",
+        name="Pyotr",
+        patronymic="Petrovich",
+        group="MEN-201",
+        repo="learning-process/parallel_programming_course",
+        num_variants=31,  # produces values in 0..30
+    )
+    print(v)
+"""
+
+from __future__ import annotations
+
+import hashlib
+import re
+import unicodedata
+from typing import Optional
+
+__all__ = ["assign_variant", "normalize"]
+
+
+def normalize(s: Optional[str]) -> str:
+    """
+    Normalize a string:
+      - Unicode NFKC,
+      - trim,
+      - lowercase,
+      - map Cyrillic 'ё' -> 'е' (common normalization in Russian names),
+      - collapse multiple spaces to a single space.
+
+    None -> '' (empty string).
+    """
+    if not s:
+        return ""
+    s = unicodedata.normalize("NFKC", s).strip().lower()
+    s = s.replace("ё", "е")
+    s = re.sub(r"\s+", " ", s)
+    return s
+
+
+def _hash_int(key: str) -> int:
+    """Return SHA-256(key) as a big integer."""
+    return int.from_bytes(hashlib.sha256(key.encode("utf-8")).digest(), "big")
+
+
+def assign_variant(
+        surname: str,
+        name: str,
+        group: str,
+        repo: str,
+        patronymic: Optional[str] = "",
+        num_variants: int = 31,
+) -> int:
+    """
+    Deterministically returns a variant index in [0 .. num_variants-1]
+    based on (surname, name, patronymic, group) and the repository name (repo)
+    as the sole salt.
+
+    :param surname: Last name
+    :param name: First name
+    :param group: Group identifier (e.g., "MEN-201")
+    :param repo: Repository name used as salt (e.g., "org/repo" or just "repo")
+    :param patronymic: Middle name / patronymic (optional)
+    :param num_variants: Total number of variants (> 0). Output range: 0..num_variants-1
+    :return: int — the variant index
+    """
+    if not isinstance(num_variants, int) or num_variants < 1:
+        raise ValueError("num_variants must be a positive integer (> 0)")
+    if not repo or not isinstance(repo, str):
+        raise ValueError("repo must be a non-empty string")
+
+    key = "|".join(
+        (
+            normalize(surname),
+            normalize(name),
+            normalize(patronymic),
+            normalize(group),
+            normalize(repo),
+        )
+    )
+    h = _hash_int(key)
+    return h % num_variants
+
+
+# Minimal self-check when executed directly (no CLI arguments).
+if __name__ == "__main__":
+    def demo():
+        print("Demo: deterministic assignment\n")
+
+        v1 = assign_variant(
+            surname="Петров",
+            name="Пётр",
+            patronymic="Петрович",
+            group="МЕН-201",
+            repo="learning-process/parallel_programming_course",
+            num_variants=31,
+        )
+        # Different casing/spacing/ё→е should not change the result:
+        v2 = assign_variant(
+            surname="ПЕТРОВ",
+            name="петр ",
+            patronymic="пЕТРОВИЧ",
+            group="  мен-201 ",
+            repo="learning-process/parallel_programming_course",
+            num_variants=31,
+        )
+        assert v1 == v2, "Normalization should make results identical"
+
+        v_other_repo = assign_variant(
+            surname="Petrov",
+            name="Pyotr",
+            patronymic="Petrovich",
+            group="MEN-201",
+            repo="learning-process/ppc_2025_fall",  # different salt → likely different value
+            num_variants=31,
+        )
+
+        print(f"Variant (repo=A): {v1}")
+        print(f"Variant (same inputs, normalized): {v2}")
+        print(f"Variant (repo=B): {v_other_repo}")
+        print("\nOK: deterministic & normalized.")
+
+    demo()

scoreboard/data/performance.yml

@@ -6,3 +6,11 @@ plagiarism:
   stl: []
   tbb: []
   all: []
+
+deadlines:
+  mpi: "2025-12-31"
+  omp: "2025-12-31"
+  seq: "2025-12-31"
+  stl: "2025-12-31"
+  tbb: "2025-12-31"
+  all: "2025-12-31"

scoreboard/data/plagiarism.yml

@@ -0,0 +1,63 @@
+processes:
+  semester_total: 70
+  tasks:
+    - name: mpi_task_1
+      mpi:
+        - S: 8
+        - A: 0
+      seq:
+        - S: 2
+      R: 2
+      variants_max: 27
+      Total: 12
+    - name: mpi_task_2
+      mpi:
+        - S: 12
+        - A: 5
+      seq:
+        - S: 3
+      R: 3
+      variants_max: 23
+      Total: 23
+    - name: mpi_task_3
+      mpi:
+        - S: 16
+        - A: 10
+      seq:
+        - S: 4
+      R: 5
+      variants_max: 32
+      Total: 35
+threads:
+  semester_total: 64
+  variants_max: 30
+  tasks:
+    - name: seq
+      S: 4
+      R: 1
+      Total: 5
+    - name: omp
+      S: 6
+      A: 3
+      R: 2
+      Total: 11
+    - name: tbb
+      S: 6
+      A: 3
+      R: 2
+      Total: 11
+    - name: stl
+      S: 8
+      A: 6
+      R: 2
+      Total: 16
+    - name: all
+      S: 10
+      A: 8
+      R: 3
+      Total: 21
+efficiency:
+  num_proc: 4
+plagiarism:
+  coefficient: 0.5
+  note: "Penalty P = -coefficient * S (scoreboard notation)"