christoph/lecture-operating-system-development
1
Fork 0
Code Activity

rename Vector to vector

Browse Source
This commit is contained in:
Christoph Urlacher
2022-07-23 21:37:00 +02:00
parent c8db2c8878
commit c95361552a
8 changed files with 23 additions and 27 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
c_os/kernel/threads/Scheduler.cc
View File

@ -35,7 +35,7 @@ constexpr const bool INSANE_TRACE = false;
* Parameter: *
* next Thread der die CPU erhalten soll. *
*****************************************************************************/
void Scheduler::start(bse::Vector<bse::unique_ptr<Thread>>::Iterator next) {
void Scheduler::start(bse::vector<bse::unique_ptr<Thread>>::Iterator next) {
active = next;
if (active >= ready_queue.end()) {
active = ready_queue.begin();
@ -47,7 +47,7 @@ void Scheduler::start(bse::Vector<bse::unique_ptr<Thread>>::Iterator next) {
(*active)->start(); // First dereference the Iterator, then the unique_ptr to get Thread
}
void Scheduler::switch_to(Thread* prev_raw, bse::Vector<bse::unique_ptr<Thread>>::Iterator next) {
void Scheduler::switch_to(Thread* prev_raw, bse::vector<bse::unique_ptr<Thread>>::Iterator next) {
active = next;
if (active >= ready_queue.end()) {
active = ready_queue.begin();
@ -137,7 +137,7 @@ void Scheduler::kill(unsigned int tid, bse::unique_ptr<Thread>* ptr) {
unsigned int prev_tid = (*active)->tid;
// Block queue, can always kill
for (bse::Vector<bse::unique_ptr<Thread>>::Iterator it = block_queue.begin(); it != block_queue.end(); ++it) {
for (bse::vector<bse::unique_ptr<Thread>>::Iterator it = block_queue.begin(); it != block_queue.end(); ++it) {
if ((*it)->tid == tid) {
// Found thread to kill
@ -163,7 +163,7 @@ void Scheduler::kill(unsigned int tid, bse::unique_ptr<Thread>* ptr) {
return;
}
for (bse::Vector<bse::unique_ptr<Thread>>::Iterator it = ready_queue.begin(); it != ready_queue.end(); ++it) {
for (bse::vector<bse::unique_ptr<Thread>>::Iterator it = ready_queue.begin(); it != ready_queue.end(); ++it) {
if ((*it)->tid == tid) {
// Found thread to kill
@ -318,7 +318,7 @@ void Scheduler::deblock(unsigned int tid) {
cpu.disable_int();
for (bse::Vector<bse::unique_ptr<Thread>>::Iterator it = block_queue.begin(); it != block_queue.end(); ++it) {
for (bse::vector<bse::unique_ptr<Thread>>::Iterator it = block_queue.begin(); it != block_queue.end(); ++it) {
if ((*it)->tid == tid) {
// Found thread with correct tid

15
c_os/kernel/threads/Scheduler.h
View File

@ -23,25 +23,20 @@ private:
NamedLogger log;
// NOTE: Using this instead of the Queue is a side effect, I added the ArrayList for different reasons
// but my Queue was shit so I replaced it
// I want to use the queue again to get rid of the Vector overhead (copy + dynamic memory) but
// this is problematic with the unique_ptr, I guess I would have to wrap the threads in the "Chain"
// elements instead of a thread being a "Chain"
bse::Vector<bse::unique_ptr<Thread>> ready_queue;
bse::Vector<bse::unique_ptr<Thread>> block_queue;
bse::vector<bse::unique_ptr<Thread>> ready_queue;
bse::vector<bse::unique_ptr<Thread>> block_queue;
// NOTE: It makes sense to keep track of the active thread through this as it makes handling the
// unique_ptr easier and reduces the copying in the vector when cycling through the threads
bse::Vector<bse::unique_ptr<Thread>>::Iterator active = nullptr;
bse::vector<bse::unique_ptr<Thread>>::Iterator active = nullptr;
// Scheduler wird evt. von einer Unterbrechung vom Zeitgeber gerufen,
// bevor er initialisiert wurde
unsigned int idle_tid = 0U;
// Roughly the old dispatcher functionality
void start(bse::Vector<bse::unique_ptr<Thread>>::Iterator next); // Start next without prev
void switch_to(Thread* prev_raw, bse::Vector<bse::unique_ptr<Thread>>::Iterator next); // Switch from prev to next
void start(bse::vector<bse::unique_ptr<Thread>>::Iterator next); // Start next without prev
void switch_to(Thread* prev_raw, bse::vector<bse::unique_ptr<Thread>>::Iterator next); // Switch from prev to next
// Kann nur vom Idle-Thread aufgerufen werden (erster Thread der vom Scheduler gestartet wird)
void enable_preemption(unsigned int tid) { idle_tid = tid; }

3
c_os/lib/Semaphore.h
View File

@ -14,13 +14,14 @@
#include "kernel/threads/Thread.h"
#include "lib/SpinLock.h"
#include "user/lib/Vector.h"
#include <vector>
class Semaphore {
private:
Semaphore(const Semaphore& copy) = delete; // Verhindere Kopieren
// Queue fuer wartende Threads.
bse::Vector<unsigned int> wait_queue;
bse::vector<unsigned int> wait_queue;
SpinLock lock;
int counter;

2
c_os/user/demo/SmartPointerDemo.cc
View File

@ -110,7 +110,7 @@ void SmartPointerDemo::run() {
{
log.info() << "ArrayList<bse::unique_ptr<int>>..." << endl;
bse::Vector<bse::unique_ptr<int>> vec;
bse::vector<bse::unique_ptr<int>> vec;
log.info() << "2x insertion" << endl;
vec.push_back(bse::make_unique<int>(1));
vec.push_back(bse::make_unique<int>(2));

4
c_os/user/demo/VectorDemo.cc
View File

@ -1,6 +1,6 @@
#include "user/demo/VectorDemo.h"
void print(bse::Vector<int> list) {
void print(bse::vector<int> list) {
kout << "Printing List: ";
for (int i : list) {
kout << i << " ";
@ -9,7 +9,7 @@ void print(bse::Vector<int> list) {
}
void VectorDemo::run() {
bse::Vector<int> list;
bse::vector<int> list;
kout.lock();
kout.clear();

2
c_os/user/event/KeyEventManager.cc
View File

@ -8,7 +8,7 @@ void KeyEventManager::subscribe(KeyEventListener& sub) {
void KeyEventManager::unsubscribe(KeyEventListener& unsub) {
log.debug() << "Unsubscribe, Thread ID: " << dec << unsub.tid << endl;
for (bse::Vector<KeyEventListener*>::Iterator it = listeners.begin(); it != listeners.end(); ++it) {
for (bse::vector<KeyEventListener*>::Iterator it = listeners.begin(); it != listeners.end(); ++it) {
if ((*it)->tid == unsub.tid) {
this->listeners.erase(it);
return;

2
c_os/user/event/KeyEventManager.h
View File

@ -14,7 +14,7 @@ private:
NamedLogger log;
bse::Vector<KeyEventListener*> listeners;
bse::vector<KeyEventListener*> listeners;
public:
KeyEventManager() : log("KEvMan") {}

12
c_os/user/lib/Vector.h
View File

@ -13,7 +13,7 @@
namespace bse {
template<typename T>
class Vector {
class vector {
public:
using Iterator = ContinuousIterator<T>;
@ -27,8 +27,8 @@ namespace bse {
std::size_t buf_cap = 0;
void init() {
buf = new T[Vector::default_cap];
buf_cap = Vector::default_cap;
buf = new T[vector::default_cap];
buf_cap = vector::default_cap;
}
std::size_t get_rem_cap() const {
@ -98,7 +98,7 @@ namespace bse {
}
public:
~Vector() {
~vector() {
for (std::size_t i; i < size(); ++i) {
buf[i].~T(); // TODO: I think delete[] buf calls these, verify that
}
@ -237,9 +237,9 @@ namespace bse {
// NOTE: pred is no real predicate as one would need closures for this, but we don't have <functional> available
// This means the result has to be passed separately and the function differs from the c++20 std::erase_if
template<typename T, typename arg>
std::size_t erase_if(Vector<T>& vec, arg (*pred)(const T&), arg result) {
std::size_t erase_if(vector<T>& vec, arg (*pred)(const T&), arg result) {
std::size_t erased_els = 0;
for (typename Vector<T>::Iterator it = vec.begin(); it != vec.end(); /*Do nothing*/) {
for (typename vector<T>::Iterator it = vec.begin(); it != vec.end(); /*Do nothing*/) {
if (pred(*it) == result) {
it = vec.erase(it); // erase returns the iterator to the next element
++erased_els;