mirror of
https://github.com/kuhyx/WUT_Computer_Science.git
synced 2026-11-11 00:27:08 +01:00
Krzysztof kuhy Rudnicki
faef20dc45
598 findings to none, and the suite ran through `./run.sh run` after each step rather than at the end -- 18 passed, 27s, every time. The shape of this one was different from the other courses. PORR is four implementations of the same linear algebra (sequential, threads, processes, dask), so nearly every finding came in groups of four: - 229 missing annotations. Rather than `object`, which mypy strict rejects on every attribute access, each module declares what these actually are: `Matrix = np.ndarray | list[list[float]]` and the vector equivalent. The backends really are called with both -- comparing them is the point of the course. - 76 names: `A` -> matrix, `Ab` -> augmented, `Ax` -> product, `I` -> identity, `dA` -> dask_matrix, and the two CamelCase functions. Renamed through `tokenize`, not regex, so no string or comment was touched. - 121 missing docstrings, one per method name since the names repeat across all four backends. - Seven functions over the argument limit, all taking the same seven or nine loose values. They are two frozen dataclasses now, in a new richardson_problem.py: `Problem(matrix, rhs, lambda_min, lambda_max)` and `Settings(max_iterations, x0, tol)`. `RichardsonMethod.__init__` also took a `size` argument it never read. - threads_indep_old's iteration did "split into chunks, submit, wait" four times by hand (C901 11, PLR0915 54). One `_run_chunked` helper. - tests.py's two bare asserts became explicit raises, per the no-ignores rule. `assert False` was also B011: `python -O` deletes it, so the non-convergence branch would have silently passed under optimisation. Real fixes rather than style: np.random -> Generator, `os.path.exists` -> Path, an `except Exception` around dask narrowed to the errors it actually raises, and two runnable modules that logged at INFO without ever calling basicConfig -- caught by scripts/check_refactor_safety.py, which is now doing the job it was written for. Repo-wide: 1,781 findings -> 1,183, all of them in the five courses left. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_0172dj34FDpao6wsix8ZuCzE
100 lines
2.8 KiB
Python
Executable File
100 lines
2.8 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
"""Threaded Richardson, the first attempt (one thread per slice)."""
|
|
|
|
import gc
|
|
import logging
|
|
import multiprocessing
|
|
import sys
|
|
import threading
|
|
import time
|
|
|
|
import numpy as np
|
|
from richardson_problem import Problem, Settings
|
|
from time_measurement import (
|
|
longest_time_accumulator,
|
|
tests_time,
|
|
time_measurement_longest,
|
|
)
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
# Called with numpy arrays here and with plain lists in the sequential
|
|
# backend; the aliases name both.
|
|
Matrix = np.ndarray | list[list[float]]
|
|
Vector = np.ndarray | list[float]
|
|
|
|
|
|
@time_measurement_longest(longest_time_accumulator)
|
|
def richardson_thread(
|
|
matrix: Matrix,
|
|
b: Vector,
|
|
vectors: tuple[Vector, Vector],
|
|
omega: float,
|
|
span: tuple[int, int],
|
|
) -> None:
|
|
"""Run one thread's slice of a Richardson iteration.
|
|
|
|
``vectors`` is (x, next_x) and ``span`` is the half-open row range this
|
|
thread owns.
|
|
"""
|
|
x, _x = vectors
|
|
start, end = span
|
|
for i in range(start, end):
|
|
sigma = np.dot(matrix[i, :], _x) - matrix[i, i] * _x[i]
|
|
x[i] = (1 - omega) * _x[i] + omega * (b[i] - sigma) / matrix[i, i]
|
|
|
|
|
|
def richardson_method_threads(
|
|
problem: Problem, settings: Settings
|
|
) -> tuple[Vector, str | None]:
|
|
"""Run Richardson with one thread per chunk."""
|
|
matrix = problem.matrix
|
|
b = problem.rhs
|
|
max_iterations = settings.max_iterations
|
|
x0 = settings.x0
|
|
longest_time_accumulator.total_time = 0
|
|
longest_time_accumulator.start = sys.float_info.max
|
|
longest_time_accumulator.end = 0
|
|
|
|
gc.disable()
|
|
start_time = time.perf_counter()
|
|
|
|
n = len(b)
|
|
x0 = x0 if x0 is not None else [0.0] * len(b)
|
|
x = x0[:]
|
|
omega = 0.05 # 2 / (lambda_min + lambda_max)
|
|
num_threads = multiprocessing.cpu_count()
|
|
threads = []
|
|
chunk_size = n // num_threads
|
|
max_iterations = 1000
|
|
|
|
for _ in range(max_iterations):
|
|
_x = x[:]
|
|
for i in range(num_threads):
|
|
# start is an index into A: each thread gets the next multiple of
|
|
# the per-thread chunk size as its starting point.
|
|
start = i * chunk_size
|
|
end = n if i == num_threads - 1 else (i + 1) * chunk_size
|
|
thread = threading.Thread(
|
|
target=richardson_thread, args=(matrix, b, (x, _x), omega, (start, end))
|
|
)
|
|
threads.append(thread)
|
|
thread.start()
|
|
|
|
for thread in threads:
|
|
thread.join()
|
|
end_time = time.perf_counter()
|
|
gc.enable()
|
|
total_time = end_time - start_time
|
|
sequential_time = total_time - longest_time_accumulator.total_time
|
|
|
|
logger.info(
|
|
"Total: %ss, Seq: %ss, Parallel (threads): %ss, Tests time: %ss",
|
|
total_time,
|
|
sequential_time,
|
|
longest_time_accumulator.total_time,
|
|
tests_time.total_time,
|
|
)
|
|
|
|
return x, 0
|