Skip to content
Snippets Groups Projects
Commit f91aa980 authored by Pavel Veselý's avatar Pavel Veselý
Browse files

new semester cleanup

parent f985c814
Branches
No related tags found
No related merge requests found
Expand all Show whitespace changes
Inline Side-by-side
Showing
with 0 additions and 1414 deletions
06-matrix_transpose/python/matrix_tests.py deleted 100644 → 0
+ 0
− 165
View file @ f985c814
from matrix_transpose import Matrix
import numpy
# Description of memory blocks is stored in an array blocks[block_index][B_xxx].
# If the block is cached, B_CACHED is 1 and B_LRU_NEXT and B_LRU_PREV point to
# neighboring blocks in the cyclic LRU list. Otherwise, B_CACHED is 0 and the block
# is not in the LRU.
B_CACHED = 0
B_LRU_NEXT = 1
B_LRU_PREV = 2
class CachedMatrix(Matrix):
"""A matrix stored in simulated cache"""
def __init__(self, N, M, B, debug_level=0):
assert N>0, "CachedMatrix must be non-empty."
assert B>0, "Blocks must be non-empty."
assert M%B == 0, "Cache size must be divisible by block size."
assert M >= 2*B, "Cache must have at least 2 blocks."
Matrix.__init__(self, N)
NN = N*N
self.items = numpy.zeros(shape=NN, dtype=numpy.int32, order="C")
self.B = B
self.M = M
self.debug_level = debug_level
self.mem_blocks = (NN+B-1) // B
self.cache_blocks = M//B
self.cache_used = 0
# Initialize the LRU list. There is a virtual block right after the last real block,
# which serves as a head of the cyclic LRU list.
self.blocks = numpy.zeros(shape=(self.mem_blocks+1, 3), dtype=numpy.int32, order="C")
self.lru_head = self.mem_blocks
self.blocks[self.lru_head, B_LRU_NEXT] = self.lru_head
self.blocks[self.lru_head, B_LRU_PREV] = self.lru_head
self.reset_stats()
if debug_level > 0:
print("\tMemory: {} blocks of {} items, {} cached".format(self.mem_blocks, self.B, self.cache_blocks))
def _pos(self, i, j):
"""Convert position in matrix to linear address in simulated memory."""
return i*self.N + j
def read(self, i, j):
"""Read value at position (i,j), used only in testing code."""
assert i >= 0 and i < self.N and j >= 0 and j < self.N, "Read out of range: ({},{})".format(i, j)
addr = self._pos(i, j)
self._access(addr)
return self.items[addr]
def write(self, i, j, value):
"""Write value at position (i,j), used only in testing code."""
assert i >= 0 and i < self.N and j >= 0 and j < self.N, "Write out of range: ({},{})".format(i, j)
addr = self._pos(i, j)
self._access(addr)
self.items[addr] = value
def swap(self, i1, j1, i2, j2):
"""Swap items (i1,j1) and (i2,j2)."""
assert i1 >= 0 and i1 < self.N and j1 >= 0 and j1 < self.N and \
i2 >= 0 and i2 < self.N and j2 >= 0 and j2 < self.N, \
"Swap out of range: ({},{}) with ({},{})".format(i1, j1, i2, j2)
if self.debug_level > 1:
print("\tSwap ({},{}) ({},{})".format(i1, j1, i2, j2))
addr1 = self._pos(i1, j1)
addr2 = self._pos(i2, j2)
self._access(addr1)
self._access(addr2)
items = self.items
items[addr1], items[addr2] = items[addr2], items[addr1]
def reset_stats(self):
"""Reset statistic counters."""
self.stat_cache_misses = 0
self.stat_accesses = 0
def _access(self, addr):
"""Bring the given address to the cache."""
blocks = self.blocks
i = addr // self.B # Which block to bring
if blocks[i, B_CACHED] > 0:
self._lru_remove(i)
else:
if self.cache_used < self.cache_blocks:
# We still have room in the cache.
self.cache_used += 1
if self.debug_level > 1:
print("\t\tLoading block {}".format(i))
else:
# We need to evict the least-recently used block to make space.
replace = blocks[self.lru_head, B_LRU_PREV]
self._lru_remove(replace)
assert blocks[replace, B_CACHED] > 0, "Internal error: Buggy LRU list"
blocks[replace, B_CACHED] = 0
if self.debug_level > 1:
print("\t\tLoading block {}, replacing {}".format(i, replace))
blocks[i, B_CACHED] = 1
self.stat_cache_misses += 1
self._lru_add_after(i, self.lru_head)
self.stat_accesses += 1
def _lru_remove(self, i):
"""Remove block from the LRU list."""
blocks = self.blocks
prev, next = blocks[i, B_LRU_PREV], blocks[i, B_LRU_NEXT]
blocks[prev, B_LRU_NEXT] = next
blocks[next, B_LRU_PREV] = prev
def _lru_add_after(self, i, after):
"""Add block at the given position in the LRU list."""
blocks = self.blocks
next = blocks[after, B_LRU_NEXT]
blocks[after, B_LRU_NEXT] = i
blocks[next, B_LRU_PREV] = i
blocks[i, B_LRU_NEXT] = next
blocks[i, B_LRU_PREV] = after
class TestMatrix(CachedMatrix):
"""A cached matrix extended by methods for testing."""
# Constructor is inherited
def fill_matrix(self):
"""Fill matrix with a testing pattern."""
if self.debug_level > 1:
print("\tInitializing")
N = self.N
for i in range(N):
for j in range(N):
self.write(i, j, i*N + j)
def check_result(self):
"""Check that the pattern corresponds to the properly transposed matrix."""
if self.debug_level > 1:
print("\tChecking")
N = self.N
for i in range(N):
for j in range(N):
want = j*N + i
have = self.read(i, j)
have_i = have // N
have_j = have % N
assert have == want, "Mismatch at position ({},{}): expected element from ({},{}), found element from ({},{})".format(i, j, j, i, have_i, have_j)
def naive_transpose(self):
"""Transpose the matrix naively."""
for i in range(self.N):
for j in range(i):
self.swap(i, j, j, i)
06-matrix_transpose/python/matrix_transpose.py deleted 100644 → 0
+ 0
− 24
View file @ f985c814
class Matrix:
"""Interface of a matrix.
This class provides only the matrix size N and a method for swapping
two items. The actual storage of the matrix in memory is provided by
subclasses in testing code.
"""
def __init__(self, N):
self.N = N
def swap(self, i1, j1, i2, j2):
"""Swap elements (i1,j1) and (i2,j2)."""
# Overridden in subclasses
raise NotImplementedError
def transpose(self):
"""Transpose the matrix."""
# TODO: Implement more efficiently
for i in range(self.N):
for j in range(i):
self.swap(i, j, j, i)
06-matrix_transpose/python/matrix_transpose_test.py deleted 100644 → 0
+ 0
− 44
View file @ f985c814
#!/usr/bin/env python3
import math
import sys
from matrix_tests import TestMatrix
def generic_test(N, M, B, max_ratio, debug_level):
m = TestMatrix(N, M, B, debug_level)
m.fill_matrix()
m.reset_stats()
m.transpose()
print("\t{} misses in {} accesses".format(m.stat_cache_misses, m.stat_accesses))
if m.stat_accesses:
swaps = N * (N-1) / 2
mpa = m.stat_cache_misses / swaps
lb = 2. / B
ratio = mpa / lb
print("\t{:.6f} misses/swap (lower bound is {:.6f} => ratio {:.6f}, limit {:.6f})".format(mpa, lb, ratio, max_ratio))
assert ratio <= max_ratio, "Algorithm did too many I/O operations."
m.check_result()
# A list of all tests
tests = [
# name N M B max_ratio debug_level
("small2k", lambda: generic_test( 8, 32, 8, 8, 2 )),
("small", lambda: generic_test( 13, 64, 8, 5, 2 )),
("n100b16", lambda: generic_test( 100, 1024, 16, 3, 1 )),
("n1000b16", lambda: generic_test(1000, 1024, 16, 3, 1 )),
("n1000b64", lambda: generic_test(1000, 8192, 64, 4, 1 )),
("n1000b256", lambda: generic_test(1000, 65536, 256, 7, 1 )),
("n1000b4096", lambda: generic_test(1000, 65536, 4096, 60, 1 )),
]
if __name__ == "__main__":
for required_test in sys.argv[1:] or [name for name, _ in tests]:
for name, test in tests:
if name == required_test:
print("Running test {}".format(name), file=sys.stderr)
test()
break
else:
raise ValueError("Unknown test {}".format(name))
06-matrix_transpose/task.md deleted 100644 → 0
+ 0
− 6
View file @ f985c814
Implement cache-oblivious transposition of square matrices.
The Python version requires the NumPy module for storing the matrix
in memory efficiently.
Source code templates can be found in [git](https://gitlab.kam.mff.cuni.cz/datovky/assignments/-/tree/master).
07-matrix_experiment/cpp/Makefile deleted 100644 → 0
+ 0
− 26
View file @ f985c814
.PHONY: test
test: matrix_experiment_sim matrix_experiment_real
@rm -rf out && mkdir out
@for exp in m1024-b16 m8192-b64 m65536-b256 m65536-b4096 ; do \
for impl in smart naive ; do \
echo "t-sim-$$exp-$$impl" ; \
./matrix_experiment_sim $$exp $$impl >out/t-sim-$$exp-$$impl ; \
done ; \
done
@for impl in smart naive ; do \
echo "t-real-$$impl" ; \
./matrix_experiment_real $$impl >out/t-real-$$impl ; \
done
CXXFLAGS=-std=c++11 -O3 -Wall -Wextra -g -Wno-sign-compare
matrix_experiment_sim: matrix_transpose.h matrix_tests.h matrix_experiment_sim.cpp
$(CXX) $(CPPFLAGS) $(CXXFLAGS) matrix_experiment_sim.cpp -o $@
matrix_experiment_real: matrix_transpose.h matrix_tests.h matrix_experiment_real.cpp
$(CXX) $(CPPFLAGS) $(CXXFLAGS) matrix_experiment_real.cpp -o $@
.PHONY: clean
clean::
rm -f matrix_experiment_sim matrix_experiment_real
rm -rf out
07-matrix_experiment/cpp/matrix_experiment_real.cpp deleted 100644 → 0
+ 0
− 90
View file @ f985c814
#include <functional>
#include <string>
#include <vector>
#include <cstdio>
#include <cmath>
#include <iostream>
#include <time.h>
using namespace std;
// If the condition is not true, report an error and halt.
#define EXPECT(condition, message) do { if (!(condition)) expect_failed(message); } while (0)
void expect_failed(const string& message) {
cerr << "Test error: " << message << endl;
exit(1);
}
class Matrix {
vector<unsigned> items;
unsigned &item(unsigned i, unsigned j) { return items[i*N + j]; }
public:
unsigned N;
Matrix(unsigned N) { this->N = N; items.resize(N*N, 0); }
void swap(unsigned i1, unsigned j1, unsigned i2, unsigned j2)
{
// EXPECT(i1 < N && j1 < N && i2 < N && j2 < N, "Swap out of range: " + coord_string(i1, j1) + " with " + coord_string(i2, j2) + ".");
std::swap(item(i1, j1), item(i2, j2));
}
void naive_transpose()
{
for (unsigned i=0; i<N; i++)
for (unsigned j=0; j<i; j++)
swap(i, j, j, i);
}
#include "matrix_transpose.h"
};
void real_test(bool naive)
{
for (int e=40; e<=112; e++) {
unsigned N = (unsigned) pow(2, e/8.);
Matrix m(N);
clock_t start_time, stop_time;
unsigned tries = 1;
do {
start_time = clock();
for (unsigned t=0; t < tries; t++) {
if (naive)
m.naive_transpose();
else
m.transpose();
}
stop_time = clock();
tries *= 2;
} while (stop_time - start_time < CLOCKS_PER_SEC/10);
// It is guaranteed that the total number of tries is odd :)
double ns_per_item = (double)(stop_time - start_time) / CLOCKS_PER_SEC / (N*(N-1)) / tries * 1e9;
printf("%d\t%.6f\n", N, ns_per_item);
}
}
int main(int argc, char **argv)
{
if (argc != 2) {
fprintf(stderr, "Usage: %s (smart|naive)\n", argv[0]);
return 1;
}
std::string mode = argv[1];
bool naive;
if (mode == "smart")
naive = false;
else if (mode == "naive")
naive = true;
else {
fprintf(stderr, "The argument must be either 'smart' or 'naive'\n");
return 1;
}
real_test(naive);
return 0;
}
07-matrix_experiment/cpp/matrix_experiment_sim.cpp deleted 100644 → 0
+ 0
− 80
View file @ f985c814
#include <functional>
#include <string>
#include <vector>
#include <cstdio>
#include <cmath>
#include <string>
#include <iostream>
#include <time.h>
using namespace std;
// If the condition is not true, report an error and halt.
#define EXPECT(condition, message) do { if (!(condition)) expect_failed(message); } while (0)
void expect_failed(const string& message) {
cerr << "Test error: " << message << endl;
exit(1);
}
#include "matrix_tests.h"
void simulated_test(unsigned M, unsigned B, bool naive)
{
for (int e=20; e<=52; e++) {
unsigned N = (unsigned) pow(2, e/4.);
TestMatrix m(N, M, B, 0);
m.fill_matrix();
m.reset_stats();
if (naive)
m.naive_transpose();
else
m.transpose();
double misses_per_item = (double) m.stat_cache_misses / (N*(N-1));
printf("%d\t%.6f\n", N, misses_per_item);
m.check_result();
}
}
vector<pair<string, function<void(bool n)>>> tests = {
// M B
{ "m1024-b16", [](bool n) { simulated_test( 1024, 16, n); } },
{ "m8192-b64", [](bool n) { simulated_test( 8192, 64, n); } },
{ "m65536-b256", [](bool n) { simulated_test(65536, 256, n); } },
{ "m65536-b4096", [](bool n) { simulated_test(65536, 4096, n); } },
};
int main(int argc, char **argv)
{
if (argc != 3) {
fprintf(stderr, "Usage: %s <test> (smart|naive)\n", argv[0]);
return 1;
}
std::string which_test = argv[1];
std::string mode = argv[2];
bool naive;
if (mode == "smart")
naive = false;
else if (mode == "naive")
naive = true;
else
{
fprintf(stderr, "Last argument must be either 'smart' or 'naive'\n");
return 1;
}
for (const auto& test : tests) {
if (test.first == which_test) {
test.second(naive);
return 0;
}
}
fprintf(stderr, "Unknown test %s\n", which_test.c_str());
return 1;
}
07-matrix_experiment/cpp/matrix_tests.h deleted 100644 → 0
+ 0
− 213
View file @ f985c814
#include <string>
#include <vector>
#include <iostream>
#include <algorithm>
/* A matrix stored in a simulated cache */
class CachedMatrix {
unsigned B; // Block size
unsigned mem_blocks; // Memory size in blocks
unsigned cache_blocks; // Cache size in blocks
unsigned cache_used; // How many blocks of cache we already used
// We store the matrix as a one-dimensional array
vector<unsigned> items;
unsigned pos(unsigned i, unsigned j) { return i*N + j; }
/*
* For each memory block, we keep the following structure.
* If the block is currently cached, we set cached == true
* and lru_prev/next point to neighboring blocks in the cyclic LRU list.
* Otherwise, cached == false and the block is not in the LRU.
*/
class MemoryBlock {
public:
unsigned lru_prev, lru_next;
bool cached;
MemoryBlock()
{
lru_prev = lru_next = 0;
cached = false;
}
};
vector<MemoryBlock> blocks;
// One block at the end of "blocks" serves as a head of the LRU list.
unsigned lru_head;
public:
// Number of rows and columns of the matrix
unsigned N;
int debug_level; // Verbosity
CachedMatrix(unsigned N, unsigned M, unsigned B, int debug_level=0)
{
EXPECT(N > 0, "CachedMatrix must be non-empty.");
EXPECT(B > 0, "Blocks must be non-empty.");
EXPECT(!(M % B), "Cache size must be divisible by block size.");
EXPECT(M >= 2*B, "Cache must have at least 2 blocks.");
unsigned NN = N*N;
items.resize(NN, 0);
this->N = N;
this->B = B;
this->debug_level = debug_level;
mem_blocks = (NN+B-1) / B;
cache_blocks = M / B;
cache_used = 0;
// Initialize the LRU list
blocks.resize(mem_blocks + 1);
lru_head = mem_blocks;
blocks[lru_head].lru_prev = lru_head;
blocks[lru_head].lru_next = lru_head;
if (debug_level > 0)
cout << "\tMemory: " << mem_blocks << " blocks of " << B << " items, " << cache_blocks << " cached\n";
}
// Read value at position (i,j), used only in testing code
unsigned read(unsigned i, unsigned j)
{
EXPECT(i < N && j < N, "Read out of range: " + coord_string(i, j) + ".");
unsigned addr = pos(i, j);
access(addr);
return items[addr];
}
// Write value at position (i,j), used only in testing code
void write(unsigned i, unsigned j, unsigned data)
{
EXPECT(i < N && j < N, "Write out of range: " + coord_string(i, j) + ".");
unsigned addr = pos(i, j);
access(addr);
items[addr] = data;
}
// Swap items (i1,j1) and (i2,j2)
void swap(unsigned i1, unsigned j1, unsigned i2, unsigned j2)
{
EXPECT(i1 < N && j1 < N && i2 < N && j2 < N, "Swap out of range: " + coord_string(i1, j1) + " with " + coord_string(i2, j2) + ".");
if (debug_level > 1)
cout << "\tSwap " << coord_string(i1, j1) << " " << coord_string(i2, j2) << endl;
unsigned addr1 = pos(i1, j1), addr2 = pos(i2, j2);
access(addr1);
access(addr2);
std::swap(items[addr1], items[addr2]);
}
unsigned stat_cache_misses;
unsigned stat_accesses;
// Reset statistic counters.
void reset_stats()
{
stat_cache_misses = 0;
stat_accesses = 0;
}
static string coord_string(unsigned i, unsigned j)
{
return "(" + to_string(i) + "," + to_string(j) + ")";
}
#include "matrix_transpose.h"
private:
// Bring the given address to the cache.
void access(unsigned addr)
{
int i = addr / B; // Which block to bring
if (blocks[i].cached) {
lru_remove(i);
} else {
if (cache_used < cache_blocks) {
// We still have room in the cache.
cache_used++;
if (debug_level > 1)
cout << "\t\tLoading block " << i << endl;
} else {
// We need to evict the least-recently used block to make space.
unsigned replace = blocks[lru_head].lru_prev;
lru_remove(replace);
EXPECT(blocks[replace].cached, "Internal error: Buggy LRU list.");
blocks[replace].cached = false;
if (debug_level > 1)
cout << "\t\tLoading block " << i << ", replacing " << replace << endl;
}
blocks[i].cached = true;
stat_cache_misses++;
}
lru_add_after(i, lru_head);
stat_accesses++;
}
// Remove block from the LRU list.
void lru_remove(unsigned i)
{
unsigned prev = blocks[i].lru_prev;
unsigned next = blocks[i].lru_next;
blocks[prev].lru_next = next;
blocks[next].lru_prev = prev;
}
// Add block at the given position in the LRU list.
void lru_add_after(unsigned i, unsigned after)
{
unsigned next = blocks[after].lru_next;
blocks[next].lru_prev = i;
blocks[after].lru_next = i;
blocks[i].lru_next = next;
blocks[i].lru_prev = after;
}
};
/* A cached matrix extended by methods for testing */
class TestMatrix : public CachedMatrix {
public:
TestMatrix(unsigned N, unsigned M, unsigned B, int debug_level = 0) : CachedMatrix(N, M, B, debug_level) { }
// Fill matrix with a testing pattern.
void fill_matrix()
{
if (debug_level > 1)
cout << "\tInitializing\n";
for (unsigned i = 0; i < N; i++)
for (unsigned j = 0; j < N; j++)
write(i, j, i*N + j);
}
// Check that the pattern corresponds to the properly transposed matrix.
void check_result()
{
if (debug_level > 1)
cout << "\tChecking\n";
for (unsigned i = 0; i < N; i++) {
for (unsigned j = 0; j < N; j++) {
unsigned want = j*N + i;
unsigned found = read(i, j);
unsigned found_i = found / N;
unsigned found_j = found % N;
EXPECT(found == want,
"Mismatch at position " + coord_string(i, j) +
": expected element from " + coord_string(j, i) +
", found element from " + coord_string(found_i, found_j) +
".");
}
}
}
// Transpose the matrix naively.
void naive_transpose()
{
for (unsigned i=0; i<N; i++)
for (unsigned j=0; j<i; j++)
swap(i, j, j, i);
}
};
07-matrix_experiment/python/Makefile deleted 100644 → 0
+ 0
− 17
View file @ f985c814
TESTS=m1024-b16 m8192-b64 m65536-b256 m65536-b4096
TESTFILES=$(addprefix out/t-sim-,$(TESTS))
.PHONY: test
test: $(addsuffix -smart,$(TESTFILES)) $(addsuffix -naive,$(TESTFILES))
out/t-sim-%-naive:
@mkdir -p out
./matrix_experiment_sim.py $* naive >$@
out/t-sim-%-smart:
@mkdir -p out
./matrix_experiment_sim.py $* smart >$@
.PHONY: clean
clean::
rm -rf out __pycache__
07-matrix_experiment/python/matrix_experiment_sim.py deleted 100755 → 0
+ 0
− 42
View file @ f985c814
#!/usr/bin/env python3
import sys
from matrix_tests import TestMatrix
def simulated_test(M, B, naive):
for e in range(10, 25):
N = int(2 ** (e/2))
print(" ", N, M, B, file=sys.stderr)
m = TestMatrix(N, M, B, 0)
m.fill_matrix()
m.reset_stats()
if naive:
m.naive_transpose()
else:
m.transpose()
misses_per_item = m.stat_cache_misses / (N*(N-1))
print(N, misses_per_item, flush=True)
m.check_result()
tests = {
# M B
"m1024-b16": lambda n: simulated_test( 1024, 16, n),
"m8192-b64": lambda n: simulated_test( 8192, 64, n),
"m65536-b256": lambda n: simulated_test(65536, 256, n),
"m65536-b4096": lambda n: simulated_test(65536, 4096, n),
}
if len(sys.argv) == 3:
test = sys.argv[1]
if sys.argv[2] == "smart":
naive = False
elif sys.argv[2] == "naive":
naive = True
else:
raise ValueError("Last argument must be either 'smart' or 'naive'")
if test in tests:
tests[test](naive)
else:
raise ValueError("Unknown test {}".format(test))
else:
raise ValueError("Usage: {} <test> (smart|naive)".format(sys.argv[0]))
07-matrix_experiment/python/matrix_tests.py deleted 100644 → 0
+ 0
− 165
View file @ f985c814
from matrix_transpose import Matrix
import numpy
# Description of memory blocks is stored in an array blocks[block_index][B_xxx].
# If the block is cached, B_CACHED is 1 and B_LRU_NEXT and B_LRU_PREV point to
# neighboring blocks in the cyclic LRU list. Otherwise, B_CACHED is 0 and the block
# is not in the LRU.
B_CACHED = 0
B_LRU_NEXT = 1
B_LRU_PREV = 2
class CachedMatrix(Matrix):
"""A matrix stored in simulated cache"""
def __init__(self, N, M, B, debug_level=0):
assert N>0, "CachedMatrix must be non-empty."
assert B>0, "Blocks must be non-empty."
assert M%B == 0, "Cache size must be divisible by block size."
assert M >= 2*B, "Cache must have at least 2 blocks."
Matrix.__init__(self, N)
NN = N*N
self.items = numpy.zeros(shape=NN, dtype=numpy.int32, order="C")
self.B = B
self.M = M
self.debug_level = debug_level
self.mem_blocks = (NN+B-1) // B
self.cache_blocks = M//B
self.cache_used = 0
# Initialize the LRU list. There is a virtual block right after the last real block,
# which serves as a head of the cyclic LRU list.
self.blocks = numpy.zeros(shape=(self.mem_blocks+1, 3), dtype=numpy.int32, order="C")
self.lru_head = self.mem_blocks
self.blocks[self.lru_head, B_LRU_NEXT] = self.lru_head
self.blocks[self.lru_head, B_LRU_PREV] = self.lru_head
self.reset_stats()
if debug_level > 0:
print("\tMemory: {} blocks of {} items, {} cached".format(self.mem_blocks, self.B, self.cache_blocks))
def _pos(self, i, j):
"""Convert position in matrix to linear address in simulated memory."""
return i*self.N + j
def read(self, i, j):
"""Read value at position (i,j), used only in testing code."""
assert i >= 0 and i < self.N and j >= 0 and j < self.N, "Read out of range: ({},{})".format(i, j)
addr = self._pos(i, j)
self._access(addr)
return self.items[addr]
def write(self, i, j, value):
"""Write value at position (i,j), used only in testing code."""
assert i >= 0 and i < self.N and j >= 0 and j < self.N, "Write out of range: ({},{})".format(i, j)
addr = self._pos(i, j)
self._access(addr)
self.items[addr] = value
def swap(self, i1, j1, i2, j2):
"""Swap items (i1,j1) and (i2,j2)."""
assert i1 >= 0 and i1 < self.N and j1 >= 0 and j1 < self.N and \
i2 >= 0 and i2 < self.N and j2 >= 0 and j2 < self.N, \
"Swap out of range: ({},{}) with ({},{})".format(i1, j1, i2, j2)
if self.debug_level > 1:
print("\tSwap ({},{}) ({},{})".format(i1, j1, i2, j2))
addr1 = self._pos(i1, j1)
addr2 = self._pos(i2, j2)
self._access(addr1)
self._access(addr2)
items = self.items
items[addr1], items[addr2] = items[addr2], items[addr1]
def reset_stats(self):
"""Reset statistic counters."""
self.stat_cache_misses = 0
self.stat_accesses = 0
def _access(self, addr):
"""Bring the given address to the cache."""
blocks = self.blocks
i = addr // self.B # Which block to bring
if blocks[i, B_CACHED] > 0:
self._lru_remove(i)
else:
if self.cache_used < self.cache_blocks:
# We still have room in the cache.
self.cache_used += 1
if self.debug_level > 1:
print("\t\tLoading block {}".format(i))
else:
# We need to evict the least-recently used block to make space.
replace = blocks[self.lru_head, B_LRU_PREV]
self._lru_remove(replace)
assert blocks[replace, B_CACHED] > 0, "Internal error: Buggy LRU list"
blocks[replace, B_CACHED] = 0
if self.debug_level > 1:
print("\t\tLoading block {}, replacing {}".format(i, replace))
blocks[i, B_CACHED] = 1
self.stat_cache_misses += 1
self._lru_add_after(i, self.lru_head)
self.stat_accesses += 1
def _lru_remove(self, i):
"""Remove block from the LRU list."""
blocks = self.blocks
prev, next = blocks[i, B_LRU_PREV], blocks[i, B_LRU_NEXT]
blocks[prev, B_LRU_NEXT] = next
blocks[next, B_LRU_PREV] = prev
def _lru_add_after(self, i, after):
"""Add block at the given position in the LRU list."""
blocks = self.blocks
next = blocks[after, B_LRU_NEXT]
blocks[after, B_LRU_NEXT] = i
blocks[next, B_LRU_PREV] = i
blocks[i, B_LRU_NEXT] = next
blocks[i, B_LRU_PREV] = after
class TestMatrix(CachedMatrix):
"""A cached matrix extended by methods for testing."""
# Constructor is inherited
def fill_matrix(self):
"""Fill matrix with a testing pattern."""
if self.debug_level > 1:
print("\tInitializing")
N = self.N
for i in range(N):
for j in range(N):
self.write(i, j, i*N + j)
def check_result(self):
"""Check that the pattern corresponds to the properly transposed matrix."""
if self.debug_level > 1:
print("\tChecking")
N = self.N
for i in range(N):
for j in range(N):
want = j*N + i
have = self.read(i, j)
have_i = have // N
have_j = have % N
assert have == want, "Mismatch at position ({},{}): expected element from ({},{}), found element from ({},{})".format(i, j, j, i, have_i, have_j)
def naive_transpose(self):
"""Transpose the matrix naively."""
for i in range(self.N):
for j in range(i):
self.swap(i, j, j, i)
07-matrix_experiment/task.md deleted 100644 → 0
+ 0
− 90
View file @ f985c814
## Goal
The goal of this assignment is to evaluate your implementation of cache-oblivious
matrix transposition experimentally and to compare it with the trivial algorithm
which transposes by definition.
You are given a test program (`matrix_experiment_sim`) which evaluates your
implementation from the previous assignment on different simulated caches and
matrices of different sizes. For each experiment, the average number of cache
misses per item is reported (the diagonal items which do not move are not
counted). The program also evaluates performance of the trivial transposition algorithm.
The simulated cache is fully associative and uses LRU replacement strategy.
You should run these experiments and write a report, which contains one plot of
the measured data for each cache type, showing dependency of the average number of
misses per item on the matrix size. There should be two curves in each plot: one for your
algorithm, another for the trivial one.
The report should discuss the experimental results and try to explain the observed
behavior (including any strange anomalies) using theory from the lectures.
If you want, you can carry out further experiments to gain better understanding
of the algorithm and include these in the report.
You should submit a PDF file with the report (and no source code).
You will get 1 temporary point upon submission if the file is syntactically correct;
proper points will be assigned later.
## Test program
The test program is given two arguments:
- Cache type:
- `m1024-b16` – cache of 1024 items organized in 16-item blocks
- `m8192-b64` – cache of 8192 items organized in 64-item blocks
- `m65536-b256` – cache of 65536 items organized on 256-item blocks
- `m65536-b4096` – cache of 65536 items organized in 4096-item blocks
- The implementation to test (`smart` or `naive`).
The output of the program contains one line per experiment, which consists of
the matrix size and the average number of cache misses per item.
*Warning:* The Python tests are slow, even though they use only a subset of the
matrix sizes. They can take about one hour to complete.
If your machine has multiple processors or cores, you can try `make -j`
to run the tests in parallel.
## Optional: Tests on real hardware (for 5 extra points)
You can also test your transposition algorithm on real hardware
using the `matrix_experiment_real` program. The matrix is stored in row-major
order, each item takes 4 bytes.
The program takes one parameter, the implementation to test: `smart` or `naive`.
Its output contains one line per experiment, which consists of the matrix size
and the average time per item in nanoseconds.
However, the program is available only for C++, because general slowness of
Python completely hides all cache effects.
Again, your report should show a plot of the measured data and discuss the observed
effects. You should also include the configuration of caches in your machine.
(If you are using Linux, you can try the `machinfo` script from
[this repository](https://gitlab.kam.mff.cuni.cz/mj/aim.git).)
## Hints
The following tools can be useful for producing nice plots:
- [pandas](https://pandas.pydata.org/)
- [matplotlib](https://matplotlib.org/)
- [gnuplot](http://www.gnuplot.info/)
A quick checklist for plots:
- Is there a caption explaining what is plotted?
- Are the axes clearly labelled? Do they have value ranges and units?
- Have you mentioned that this axis has logarithmic scale? (Logarithmic graphs
are more fitting in some cases, but you should tell.)
- Is it clear which curve means what?
- Is it clear what are the measured points and what is an interpolated
curve between them?
- Are there any overlaps? (E.g., the most interesting part of the curve
hidden underneath a label?)
- **Is the graph distorted by compression artifacts?** (No, you shouldn't use JPEG for plots!)
In your discussion, please distinguish the following kinds of claims.
It should be always clear which is which:
- Experimental results (i.e., the raw data you obtained from the experiments)
- Theoretical facts (i.e., claims we have proved mathematically)
- Your hypotheses (e.g., when you claim that the graph looks like something is true,
but you are not able to prove rigorously that it always holds)
Source code templates can be found in [git](https://gitlab.kam.mff.cuni.cz/datovky/assignments/-/tree/master).
08-cuckoo_hash/cpp/Makefile deleted 100644 → 0
+ 0
− 13
View file @ f985c814
test: cuckoo_hash_test
./$<
INCLUDE ?= .
CXXFLAGS=-std=c++20 -O2 -Wall -Wextra -g -Wno-sign-compare -Wno-array-bounds -I$(INCLUDE)
cuckoo_hash_test: cuckoo_hash_test.cpp test_main.cpp cuckoo_hash.h hash_functions.h random.h
$(CXX) $(CXXFLAGS) $(filter-out %.h,$^) -o $@
clean:
rm -f cuckoo_hash_test
.PHONY: clean test
08-cuckoo_hash/cpp/cuckoo_hash.h deleted 100644 → 0
+ 0
− 60
View file @ f985c814
#include <vector>
#include <cstdint>
#include <iostream>
const uint32_t UNUSED = 0xffffffff;
template<class Hash>
class CuckooTable {
/*
* Hash table with Cuckoo hashing.
*
* We have two hash functions, which map 32-bit keys to buckets of a common
* hash table. Unused buckets contain 0xffffffff.
*/
// The array of buckets
vector<uint32_t> table;
uint32_t num_buckets;
// Hash functions and the random generator used to create them
array<Hash,2> &hashes;
public:
CuckooTable(uint32_t num_buckets, array<Hash,2> &hashes) : num_buckets{num_buckets}, hashes{hashes}
{
// Initialize the table with the given number of buckets.
// The number of buckets is expected to stay constant.
table.resize(num_buckets, UNUSED);
}
const vector<uint32_t>& get_table() const {
return table;
}
bool lookup(uint32_t key) const {
// Check if the table contains the given key. Returns True or False.
uint32_t h0 = hashes[0].hash(key);
uint32_t h1 = hashes[1].hash(key);
return (table[h0] == key || table[h1] == key);
}
void insert(uint32_t key) {
// Insert a new key to the table. Assumes that the key is not present yet.
EXPECT(key != UNUSED, "Keys must differ from UNUSED.");
// TODO: Implement
}
uint32_t rehash(uint32_t key) {
// Relocate all items using new hash functions and insert a given key.
for (int i=0; i<2; i++)
hashes[i].regenerate();
// TODO: Implement
return key;
}
};
08-cuckoo_hash/cpp/cuckoo_hash_test.cpp deleted 100644 → 0
+ 0
− 72
View file @ f985c814
#include <functional>
#include <cstdlib>
#include <vector>
#include <string>
#include <array>
#include <iostream>
#include "hash_functions.h"
#include "cuckoo_hash.h"
template<class Hash>
void inspect_table(const CuckooTable<Hash> &cuckoo, const array<Hash,2> &hashes, uint32_t n, uint32_t table_size, uint32_t step) {
const vector<uint32_t> &table = cuckoo.get_table();
EXPECT(table.size() == table_size, "The size of table is given and it is expected not to be changed.");
for (uint32_t i = 0; i < n; i++) {
uint32_t k = step*i;
uint32_t h0 = hashes[0].hash(k), h1 = hashes[1].hash(k);;
EXPECT(table[h0] == k || table[h1] == k, "Item should be stored on one of two positions given by hash functions.");
EXPECT(h0 == h1 || table[h0] != k || table[h1] != k, "Item should be stored only on one position.");
}
for (uint32_t t = 0; t < table_size; t++) {
uint32_t k = table[t];
if (k != UNUSED) {
EXPECT(k % step == 0 && k < step * n, "Only inserted items should be stored.");
EXPECT(hashes[0].hash(k) == t || hashes[1].hash(k) == t, "Item should be stored on one of two positions given by hash functions.");
}
}
}
void simple_test(uint32_t n, uint32_t table_size_percentage) {
const uint32_t table_size = n * table_size_percentage / 100;
RandomGen random_gen(42);
array<TabulationHash,2> hashes{TabulationHash(table_size, random_gen), TabulationHash(table_size, random_gen)};
CuckooTable cuckoo(table_size, hashes);
for (uint32_t i=0; i < n; i++)
cuckoo.insert(37*i);
for (uint32_t i=0; i < n; i++) {
EXPECT(cuckoo.lookup(37*i), "Item not present in table, but it should be.");
EXPECT(!cuckoo.lookup(37*i+1), "Item present in table, even though it should not be.");
}
inspect_table(cuckoo, hashes, n, table_size, 37);
}
void multiple_test(uint32_t min_n, uint32_t max_n, uint32_t step_n, uint32_t table_size_percentage) {
for (uint32_t n = min_n; n < max_n; n += step_n) {
printf("\tn=%u\n", n);
simple_test(n, table_size_percentage);
}
}
void fixed_test() {
const uint32_t table_size = FixedHash::table_size;
array<FixedHash,2> hashes{FixedHash(0), FixedHash(1)};
CuckooTable cuckoo(table_size, hashes);
for (uint32_t k = 0; k < FixedHash::keys; k++) {
cuckoo.insert(k);
}
inspect_table(cuckoo, hashes, FixedHash::keys, table_size, 1);
}
/*** A list of all tests ***/
vector<pair<string, function<void()>>> tests = {
{ "small", [] { simple_test(100, 400); } },
{ "middle", [] { simple_test(31415, 300); } },
{ "big", [] { simple_test(1000000, 300); } },
{ "tight", [] { multiple_test(20000, 40000, 500, 205); } },
{ "fixed", fixed_test }
};
08-cuckoo_hash/cpp/hash_functions.h deleted 100644 → 0
+ 0
− 92
View file @ f985c814
#include <cstdlib>
#include <string>
#include "random.h"
using namespace std;
// If the condition is not true, report an error and halt.
#define EXPECT(condition, message) do { if (!(condition)) expect_failed(message); } while (0)
void expect_failed(const string& message);
class TabulationHash {
/*
* Hash function for hashing by tabulation.
*
* The 32-bit key is split to four 8-bit parts. Each part indexes
* a separate table of 256 randomly generated values. Obtained values
* are XORed together.
*/
size_t num_buckets;
RandomGen &random_gen;
uint32_t tables[4][256];
public:
TabulationHash(size_t num_buckets, RandomGen &random_gen) : num_buckets(num_buckets), random_gen(random_gen) {
regenerate();
}
void regenerate() {
for (int i=0; i<4; i++)
for (int j=0; j<256; j++)
tables[i][j] = random_gen.next_u32();
}
uint32_t hash(uint32_t key) const {
uint32_t h0 = key & 0xff;
uint32_t h1 = (key >> 8) & 0xff;
uint32_t h2 = (key >> 16) & 0xff;
uint32_t h3 = (key >> 24) & 0xff;
return (tables[0][h0] ^ tables[1][h1] ^ tables[2][h2] ^ tables[3][h3]) % num_buckets;
}
};
class FixedHash {
public:
static constexpr uint32_t keys = 5, max_regenerations = 6, table_size = 16;
private:
static constexpr uint32_t hashes[max_regenerations][2][keys] {
{ // Two items hashed into the same bucket by both functions
{ 1, 7, 3, 7, 10 },
{ 2, 7, 4, 7, 11 }
},
{ // Three items stored in two positions
{ 1, 7, 3, 8, 7 },
{ 2, 8, 4, 7, 8 }
},
{ // Four items stored in three positions
{ 1, 7, 7, 8, 9 },
{ 2, 8, 9, 7, 8 }
},
{ // Five should be possible to store in five positions, but the cuckoo's insert operation may not find the proper locations
{ 1, 2, 3, 4, 5 },
{ 2, 3, 4, 5, 1 }
},
{ // Five should be possible to store in six positions, the timeout in the insert may not be sufficient
{ 1, 2, 3, 4, 5 },
{ 2, 3, 4, 5, 6 }
},
{ // This should be easy
{ 8, 7, 7, 8, 12 },
{ 11, 6, 7, 9, 0 }
}
};
size_t regenerations, id;
public:
FixedHash(size_t id) : regenerations{0}, id{id} {}
uint32_t hash(uint32_t key) const {
EXPECT(key < keys, "Invalid key");
return hashes[regenerations][id][key];
}
void regenerate() {
regenerations++;
EXPECT(regenerations < max_regenerations, "Too many rehashes");
}
};
08-cuckoo_hash/cpp/random.h deleted 100644 → 0
+ 0
− 59
View file @ f985c814
#define DS1_RANDOM_H
#include <cstdint>
/*
* This is the xoroshiro128+ random generator, designed in 2016 by David Blackman
* and Sebastiano Vigna, distributed under the CC-0 license. For more details,
* see http://vigna.di.unimi.it/xorshift/.
*
* Rewritten to C++ by Martin Mares, also placed under CC-0.
*/
class RandomGen {
uint64_t state[2];
uint64_t rotl(uint64_t x, int k)
{
return (x << k) | (x >> (64 - k));
}
public:
// Initialize the generator, set its seed and warm it up.
RandomGen(unsigned int seed)
{
state[0] = seed * 0xdeadbeef;
state[1] = seed ^ 0xc0de1234;
for (int i=0; i<100; i++)
next_u64();
}
// Generate a random 64-bit number.
uint64_t next_u64(void)
{
uint64_t s0 = state[0], s1 = state[1];
uint64_t result = s0 + s1;
s1 ^= s0;
state[0] = rotl(s0, 55) ^ s1 ^ (s1 << 14);
state[1] = rotl(s1, 36);
return result;
}
// Generate a random 32-bit number.
uint32_t next_u32(void)
{
return next_u64() >> 11;
}
// Generate a number between 0 and range-1.
unsigned int next_range(unsigned int range)
{
/*
* This is not perfectly uniform, unless the range is a power of two.
* However, for 64-bit random values and 32-bit ranges, the bias is
* insignificant.
*/
return next_u64() % range;
}
};
08-cuckoo_hash/cpp/test_main.cpp deleted 100644 → 0
+ 0
− 43
View file @ f985c814
#include <cstdlib>
#include <functional>
#include <iostream>
#include <string>
#include <utility>
#include <vector>
using namespace std;
extern vector<pair<string, function<void()>>> tests;
void expect_failed(const string& message) {
cerr << "Test error: " << message << endl;
exit(1);
}
int main(int argc, char* argv[]) {
vector<string> required_tests;
if (argc > 1) {
required_tests.assign(argv + 1, argv + argc);
} else {
for (const auto& test : tests)
required_tests.push_back(test.first);
}
for (const auto& required_test : required_tests) {
bool found = false;
for (const auto& test : tests)
if (required_test == test.first) {
cerr << "Running test " << required_test << endl;
test.second();
found = true;
break;
}
if (!found) {
cerr << "Unknown test " << required_test << endl;
return 1;
}
}
return 0;
}
08-cuckoo_hash/python/cuckoo_hash.py deleted 100644 → 0
+ 0
− 42
View file @ f985c814
import math
class CuckooTable:
"""Hash table with Cuckoo hashing.
We have two hash functions, which map 32-bit keys to buckets of a common
hash table. Unused buckets contain None.
"""
def __init__(self, num_buckets, hashes):
"""Initialize the table with the given number of buckets.
The number of buckets is expected to stay constant."""
# The array of buckets
self.num_buckets = num_buckets
self.table = [None] * num_buckets
self.hashes = hashes
def get_table(self):
return self.table
def lookup(self, key):
"""Check if the table contains the given key. Returns True or False."""
b0 = self.hashes[0].hash(key)
b1 = self.hashes[1].hash(key)
# print("## Lookup key={} b0={} b1={}".format(key, b0, b1))
return self.table[b0] == key or self.table[b1] == key
def insert(self, key):
"""Insert a new key to the table. Assumes that the key is not present yet."""
# TODO: Implement
raise NotImplementedError
def rehash(self, key):
""" Relocate all items using new hash functions and insert a given key. """
# Obtain new hash functions
for i in range(2):
self.hashes[i].regenerate()
# TODO: Implement
08-cuckoo_hash/python/cuckoo_hash_test.py deleted 100755 → 0
+ 0
− 71
View file @ f985c814
This diff is collapsed.
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment