Compare commits

...

8 commits

Author SHA1 Message Date
Ahmet Kaan GÜMÜŞ
1b73889fd9 build: 👷 updated to versatile build script 2024-09-24 22:11:57 +03:00
Ahmet Kaan GÜMÜŞ
2e199e8f1c refactor: ♻️ better developer experience 2024-09-16 04:52:19 +03:00
Ahmet Kaan GÜMÜŞ
358290cfa5 refactor: ♻️ clippy 2024-09-15 12:42:10 +03:00
Ahmet Kaan GÜMÜŞ
018b6aa8ed docs: 📝 upload assets to repo itself and update links 2024-09-14 22:25:53 +03:00
Ahmet Kaan GÜMÜŞ
10424e9ee1 style: ✏️ typo 2024-08-12 00:11:28 +03:00
Ahmet Kaan GÜMÜŞ
a2d3b7b607 style: 🎨 cargo fmt 2024-08-12 00:10:29 +03:00
Ahmet Kaan GÜMÜŞ
7e2f12bea6 build: 👷 update checkout, download, upload, release workflow dependencies 2024-08-11 22:51:14 +03:00
Ahmet Kaan GÜMÜŞ
04f22c2763 feat: restart
fix: error handling
build: optimization and forbid unsafe
2024-01-15 23:08:11 +03:00
8 changed files with 323 additions and 323 deletions

View file

@ -15,7 +15,7 @@ jobs:
runs-on: ubuntu-latest runs-on: ubuntu-latest
steps: steps:
- uses: actions/checkout@v3 - uses: actions/checkout@v4
- name: Build - name: Build
run: cargo build --release --verbose run: cargo build --release --verbose
- name: Run tests - name: Run tests

View file

@ -13,7 +13,7 @@ jobs:
runs-on: ubuntu-latest runs-on: ubuntu-latest
steps: steps:
- uses: actions/checkout@v3 - uses: actions/checkout@v4
- name: Build - name: Build
run: cargo build --release --verbose run: cargo build --release --verbose
- name: Run tests - name: Run tests
@ -25,7 +25,7 @@ jobs:
runs-on: windows-latest runs-on: windows-latest
steps: steps:
- uses: actions/checkout@v3 - uses: actions/checkout@v4
- name: Build - name: Build
run: cargo build --release --verbose run: cargo build --release --verbose
- name: Run tests - name: Run tests
@ -37,7 +37,7 @@ jobs:
runs-on: macos-latest runs-on: macos-latest
steps: steps:
- uses: actions/checkout@v3 - uses: actions/checkout@v4
- name: Build - name: Build
run: cargo build --release --verbose run: cargo build --release --verbose
- name: Run tests - name: Run tests

View file

@ -2,62 +2,60 @@ name: Rust -> Build & Test & Release
on: on:
push: push:
branches: [ "main" ] branches: ["main"]
env: env:
CARGO_TERM_COLOR: always CARGO_TERM_COLOR: always
PROJECT_NAME: ${{ github.event.repository.name }}
jobs: jobs:
build_linux: build_linux:
runs-on: ubuntu-latest runs-on: ubuntu-latest
steps: steps:
- uses: actions/checkout@v3 - uses: actions/checkout@v4
- name: Build - name: Build
run: cargo build --release --verbose run: cargo build --release --verbose
- name: Run tests - name: Run tests
run: cargo test --verbose run: cargo test --verbose
- name: Upload Linux Binary - name: Upload Linux Binary
uses: actions/upload-artifact@v3 uses: actions/upload-artifact@v4
with: with:
name: banker_algorithm_linux_x64_86 name: ${{ env.PROJECT_NAME }}-linux-x64_86
path: target/release/banker-algorithm path: target/release/${{ env.PROJECT_NAME }}
build_windows: build_windows:
runs-on: windows-latest runs-on: windows-latest
steps: steps:
- uses: actions/checkout@v3 - uses: actions/checkout@v4
- name: Build - name: Build
run: cargo build --release --verbose run: cargo build --release --verbose
- name: Run tests - name: Run tests
run: cargo test --verbose run: cargo test --verbose
- name: Upload Windows Binary - name: Upload Windows Binary
uses: actions/upload-artifact@v3 uses: actions/upload-artifact@v4
with: with:
name: banker_algorithm_windows_x64_86 name: ${{ env.PROJECT_NAME }}-windows-x64_86
path: target/release/banker-algorithm.exe path: target/release/${{ env.PROJECT_NAME }}.exe
build_macos: build_macos:
runs-on: macos-latest runs-on: macos-latest
steps: steps:
- uses: actions/checkout@v3 - uses: actions/checkout@v4
- name: Build - name: Build
run: cargo build --release --verbose run: cargo build --release --verbose
- name: Run tests - name: Run tests
run: cargo test --verbose run: cargo test --verbose
- name: Upload MacOS Binary - name: Upload MacOS Binary
uses: actions/upload-artifact@v3 uses: actions/upload-artifact@v4
with: with:
name: banker_algorithm_macos_x64_86 name: ${{ env.PROJECT_NAME }}-macos-arm64
path: target/release/banker-algorithm path: target/release/${{ env.PROJECT_NAME }}
release: release:
needs: [build_linux, build_windows, build_macos] needs: [build_linux, build_windows, build_macos]
@ -65,36 +63,34 @@ jobs:
permissions: permissions:
contents: write contents: write
steps: steps:
- uses: actions/checkout@v4
- uses: actions/checkout@v3
- name: Forge a Folder - name: Forge a Folder
run: mkdir Downloads run: mkdir Downloads
working-directory: /home/runner/work/banker-algorithm/banker-algorithm/ working-directory: /home/runner/work/${{ env.PROJECT_NAME }}/${{ env.PROJECT_NAME }}/
- uses: actions/download-artifact@v3 - uses: actions/download-artifact@v4
name: Download name: Download
with: with:
path: Downloads/ path: Downloads/
- name: Rename Binaries - name: Rename Binaries
run: | run: |
mv Downloads/banker_algorithm_linux_x64_86/banker-algorithm Downloads/banker_algorithm_linux_x64_86/banker-algorithm-linux_x64_86 tree Downloads/
mv Downloads/banker_algorithm_windows_x64_86/banker-algorithm.exe Downloads/banker_algorithm_windows_x64_86/banker-algorithm-windows_x64_86.exe mv Downloads/${{ env.PROJECT_NAME }}-linux-x64_86/${{ env.PROJECT_NAME }} Downloads/${{ env.PROJECT_NAME }}-linux-x64_86/${{ env.PROJECT_NAME }}-linux-x64_86
mv Downloads/banker_algorithm_macos_x64_86/banker-algorithm Downloads/banker_algorithm_macos_x64_86/banker-algorithm-macos_x64_86 mv Downloads/${{ env.PROJECT_NAME }}-windows-x64_86/${{ env.PROJECT_NAME }}.exe Downloads/${{ env.PROJECT_NAME }}-windows-x64_86/${{ env.PROJECT_NAME }}-windows-x64_86.exe
mv Downloads/${{ env.PROJECT_NAME }}-macos-arm64/${{ env.PROJECT_NAME }} Downloads/${{ env.PROJECT_NAME }}-macos-arm64/${{ env.PROJECT_NAME }}-macos-arm64
- name: Git Commit SHA - name: Git Commit SHA
id: vars id: vars
run: | run: |
calculatedSha=$(git rev-parse --short ${{ github.sha }}) calculatedSha=$(git rev-parse --short ${{ github.sha }})
echo "short_sha=$calculatedSha" >> $GITHUB_OUTPUT echo "short_sha=$calculatedSha" >> $GITHUB_OUTPUT
- uses: softprops/action-gh-release@v0.1.15 - uses: softprops/action-gh-release@v2
name: Release name: Release
with: with:
tag_name: ${{ steps.vars.outputs.short_sha }} tag_name: ${{ steps.vars.outputs.short_sha }}
generate_release_notes: true generate_release_notes: true
files: | files: |
Downloads/*linux*/*banker* Downloads/*linux*/${{ env.PROJECT_NAME }}*
Downloads/*windows*/*banker* Downloads/*windows*/${{ env.PROJECT_NAME }}*
Downloads/*macos*/*banker* Downloads/*macos*/${{ env.PROJECT_NAME }}*

View file

@ -8,6 +8,11 @@ strip = "symbols"
opt-level = 3 opt-level = 3
overflow-checks = true overflow-checks = true
lto = true lto = true
codegen-units = 1
panic = "abort"
[lints.rust]
unsafe_code = "forbid"
[dependencies] [dependencies]
rand = "0.8.5" rand = "0.8.5"

View file

@ -2,12 +2,12 @@
>When you run the program, it will ask you to give resource capacity for A, B and C. >When you run the program, it will ask you to give resource capacity for A, B and C.
![Screenshot_20240115_012732](https://github.com/Tahinli/banker-algorithm/assets/96421894/9cdfc5c3-0622-4e5a-9ac6-afd083947cc3) <img src=assets/matrix.png>
>Program will create solvable matrixses and waits for you to give process queue correctly then checks your result. >Program will create solvable matrixses and waits for you to give process queue correctly then checks your result.
![Screenshot_20240115_012746](https://github.com/Tahinli/banker-algorithm/assets/96421894/4d7a5cd5-a99e-4354-a644-caa778e0a89e) <img src=assets/interaction.png>
>At the end you can check your answers. >At the end you can check your answers.

BIN
assets/interaction.png Normal file

Binary file not shown.

After

Width:  |  Height:  |  Size: 126 KiB

BIN
assets/matrix.png Normal file

Binary file not shown.

After

Width:  |  Height:  |  Size: 135 KiB

View file

@ -1,178 +1,199 @@
use std::io;
use rand::Rng; use rand::Rng;
use std::io;
const PROCESS_COUNT: usize = 5;
const RESOURCE_COUNT: usize = 3;
const PROCESS_COUNT:usize = 5;
const RESOURCE_COUNT:usize = 3;
fn main() { fn main() {
println!("Hello, world!"); println!("Hello, world!");
let mut restart: bool = true;
while restart {
println!("Max A Resource"); println!("Max A Resource");
let mut a:String = String::new(); let a = match get_u8_input() {
io::stdin().read_line(&mut a).unwrap(); Some(resource_input) => resource_input,
let a:u8 = a.trim().parse().unwrap(); None => return,
};
println!("Max B Resource"); println!("Max B Resource");
let mut b:String = String::new(); let b = match get_u8_input() {
io::stdin().read_line(&mut b).unwrap(); Some(resource_input) => resource_input,
let b:u8 = b.trim().parse().unwrap(); None => return,
};
println!("Max C Resource"); println!("Max C Resource");
let mut c:String = String::new(); let c = match get_u8_input() {
io::stdin().read_line(&mut c).unwrap(); Some(resource_input) => resource_input,
let c:u8 = c.trim().parse().unwrap(); None => return,
};
println!("\n\tA = {}\n\tB = {}\n\tC = {}", a,b,c); println!("\n\tA = {}\n\tB = {}\n\tC = {}", a, b, c);
if a <= 0 || b <= 0 || c <= 0 if a == 0 || b == 0 || c == 0 {
{ eprintln!("Exit: Zero as a Input is Invalid");
println!("Exit: Zero as a Input Invalid");
return; return;
} }
let mut max_needs_matrix = [[0_u8;RESOURCE_COUNT];PROCESS_COUNT]; let mut max_needs_matrix = [[0_u8; RESOURCE_COUNT]; PROCESS_COUNT];
let mut assigned_resources_matrix = [[0_u8;RESOURCE_COUNT];PROCESS_COUNT]; let mut assigned_resources_matrix = [[0_u8; RESOURCE_COUNT]; PROCESS_COUNT];
let mut info:(bool, Vec<u8>) = (false, Vec::with_capacity(PROCESS_COUNT)); let mut info: (bool, Vec<u8>) = (false, Vec::with_capacity(PROCESS_COUNT));
while !info.0 while !info.0 {
{ assign_resource_matrix(
for i in 0..PROCESS_COUNT &mut max_needs_matrix,
{ &mut assigned_resources_matrix,
let mut rng = rand::thread_rng(); a,
let random = rng.gen_range(0..a); b,
max_needs_matrix[i][0] = random; c,
if random != 0 );
{
assigned_resources_matrix[i][0] = rng.gen_range(0..random);
}
else
{
assigned_resources_matrix[i][0] = 0;
}
}
for i in 0..PROCESS_COUNT
{
let mut rng = rand::thread_rng();
let random = rng.gen_range(0..b);
max_needs_matrix[i][1] = random;
if random != 0
{
assigned_resources_matrix[i][1] = rng.gen_range(0..random);
}
else
{
assigned_resources_matrix[i][1] = 0;
}
}
for i in 0..PROCESS_COUNT
{
let mut rng = rand::thread_rng();
let random = rng.gen_range(0..c);
max_needs_matrix[i][2] = random;
if random != 0
{
assigned_resources_matrix[i][2] = rng.gen_range(0..random);
}
else
{
assigned_resources_matrix[i][2] = 0;
}
}
info = banker(a, b, c, max_needs_matrix, assigned_resources_matrix); info = banker(a, b, c, max_needs_matrix, assigned_resources_matrix);
} }
println!("Max Needs Matrix"); println!("Max Needs Matrix");
print_matrix(max_needs_matrix); print_matrix(max_needs_matrix);
println!("Assigned Resources Matrix"); println!("Assigned Resources Matrix");
print_matrix(assigned_resources_matrix); print_matrix(assigned_resources_matrix);
let mut answers:[u8;PROCESS_COUNT] = [0;PROCESS_COUNT]; let mut answers: [u8; PROCESS_COUNT] = [0; PROCESS_COUNT];
for i in 0..PROCESS_COUNT for (answer, correct_answer) in answers.iter_mut().zip(&info.1) {
{
println!("Which Process Should be Done Now ?"); println!("Which Process Should be Done Now ?");
let mut input = String::new(); match get_u8_input() {
io::stdin().read_line(&mut input).unwrap(); Some(input) => {
let input:u8 = input.trim().parse().unwrap(); *answer = input;
answers[i] = input; if *correct_answer == input {
if info.1[i] == input
{
println!("Correct"); println!("Correct");
} else {
println!("Wrong it should be = {}", correct_answer);
} }
else }
{ None => return,
println!("Wrong it should be = {}", info.1[i]);
} }
} }
println!("Your Answers"); println!("Your Answers");
for i in 0..PROCESS_COUNT for answer in answers {
{ println!("P{}", answer);
println!("P{}", answers[i]);
} }
println!("Correct Answers"); println!("Correct Answers");
for i in 0..PROCESS_COUNT for correct_answer in info.1 {
{ println!("P{}", correct_answer);
println!("P{}", info.1[i]); }
println!("Press 'r' to Restart");
let resource_input = match get_input() {
Some(input) => input,
None => return,
};
match resource_input.as_str() {
"r" => {
restart = true;
println!("-------------------------------");
}
_ => {
return;
}
}
} }
} }
fn print_matrix(matrix:[[u8;RESOURCE_COUNT];PROCESS_COUNT]) fn get_input() -> Option<String> {
{ let mut input: String = String::new();
for i in 0..5 if let Err(err_val) = io::stdin().read_line(&mut input) {
{ eprintln!("Error: Failed to Read | {}", err_val);
return None;
}
Some(input.trim_end().to_string())
}
fn get_u8_input() -> Option<u8> {
match get_input() {
Some(input) => match input.parse::<u8>() {
Ok(input) => Some(input),
Err(err_val) => {
eprintln!("Error: Failed to Convert | {}", err_val);
None
}
},
None => None,
}
}
fn assign_resource_matrix_column(
max_needs_matrix: &mut [[u8; RESOURCE_COUNT]; PROCESS_COUNT],
assigned_resources_matrix: &mut [[u8; RESOURCE_COUNT]; PROCESS_COUNT],
random_limit: u8,
which_resource: usize,
) {
for i in 0..PROCESS_COUNT {
let mut rng = rand::thread_rng();
let random = rng.gen_range(0..random_limit);
max_needs_matrix[i][which_resource] = random;
if random != 0 {
assigned_resources_matrix[i][which_resource] = rng.gen_range(0..random);
} else {
assigned_resources_matrix[i][which_resource] = 0;
}
}
}
fn assign_resource_matrix(
max_needs_matrix: &mut [[u8; RESOURCE_COUNT]; PROCESS_COUNT],
assigned_resources_matrix: &mut [[u8; RESOURCE_COUNT]; PROCESS_COUNT],
a: u8,
b: u8,
c: u8,
) {
assign_resource_matrix_column(max_needs_matrix, assigned_resources_matrix, a, 0);
assign_resource_matrix_column(max_needs_matrix, assigned_resources_matrix, b, 1);
assign_resource_matrix_column(max_needs_matrix, assigned_resources_matrix, c, 2);
}
fn print_matrix(matrix: [[u8; RESOURCE_COUNT]; PROCESS_COUNT]) {
for (i, matrix_column) in matrix.iter().enumerate() {
print!("\n\t Process {}: ", i); print!("\n\t Process {}: ", i);
for j in 0..3 for matrix_value in matrix_column {
{ if *matrix_value > 99 {
if matrix[i][j] > 99 print!(" ");
{ } else if *matrix_value > 9 {
print!(" ");
} else {
print!(" "); print!(" ");
} }
else if matrix[i][j] > 9 print!("{}", *matrix_value);
{
print!(" ");
}
else
{
print!(" ");
}
print!("{}", matrix[i][j]);
} }
println!(); println!();
} }
} }
fn banker(a:u8, b:u8, c:u8, max_needs_matrix:[[u8;RESOURCE_COUNT];PROCESS_COUNT], assigned_resources_matrix:[[u8;RESOURCE_COUNT];PROCESS_COUNT]) -> (bool, Vec<u8>) fn banker(
{ a: u8,
let mut a_remaing:u8 = 0; b: u8,
let mut b_remaing:u8 = 0; c: u8,
let mut c_remaing:u8 = 0; max_needs_matrix: [[u8; RESOURCE_COUNT]; PROCESS_COUNT],
let mut remaining_needs_matrix:[[u8;RESOURCE_COUNT];PROCESS_COUNT] = [[0;RESOURCE_COUNT];PROCESS_COUNT]; assigned_resources_matrix: [[u8; RESOURCE_COUNT]; PROCESS_COUNT],
for i in 0..PROCESS_COUNT ) -> (bool, Vec<u8>) {
{ let mut a_remaining: u8 = 0;
match a_remaing.checked_add(assigned_resources_matrix[i][0]) let mut b_remaining: u8 = 0;
{ let mut c_remaining: u8 = 0;
Some(result) => let mut remaining_needs_matrix: [[u8; RESOURCE_COUNT]; PROCESS_COUNT] =
{ [[0; RESOURCE_COUNT]; PROCESS_COUNT];
a_remaing = result; for i in 0..PROCESS_COUNT {
match a_remaining.checked_add(assigned_resources_matrix[i][0]) {
Some(result) => {
a_remaining = result;
} }
None => None => {
{
return (false, vec![]); return (false, vec![]);
} }
} }
match b_remaing.checked_add(assigned_resources_matrix[i][1]) match b_remaining.checked_add(assigned_resources_matrix[i][1]) {
{ Some(result) => {
Some(result) => b_remaining = result;
{
b_remaing = result;
} }
None => None => {
{
return (false, vec![]); return (false, vec![]);
} }
} }
match c_remaing.checked_add(assigned_resources_matrix[i][2]) match c_remaining.checked_add(assigned_resources_matrix[i][2]) {
{ Some(result) => {
Some(result) => c_remaining = result;
{
c_remaing = result;
} }
None => None => {
{
return (false, vec![]); return (false, vec![]);
} }
} }
@ -180,89 +201,69 @@ fn banker(a:u8, b:u8, c:u8, max_needs_matrix:[[u8;RESOURCE_COUNT];PROCESS_COUNT]
remaining_needs_matrix[i][1] = max_needs_matrix[i][1] - assigned_resources_matrix[i][1]; remaining_needs_matrix[i][1] = max_needs_matrix[i][1] - assigned_resources_matrix[i][1];
remaining_needs_matrix[i][2] = max_needs_matrix[i][2] - assigned_resources_matrix[i][2]; remaining_needs_matrix[i][2] = max_needs_matrix[i][2] - assigned_resources_matrix[i][2];
} }
if a_remaing > a || b_remaing > b || c_remaing > c if a_remaining > a || b_remaining > b || c_remaining > c {
{
return (false, vec![]); return (false, vec![]);
} }
a_remaing = a - a_remaing; a_remaining = a - a_remaining;
b_remaing = b - b_remaing; b_remaining = b - b_remaining;
c_remaing = c - c_remaing; c_remaining = c - c_remaining;
let mut infinite_detection:u8 = 2; let mut infinite_detection: u8 = 2;
let mut done:[bool;PROCESS_COUNT] = [false;PROCESS_COUNT]; let mut done: [bool; PROCESS_COUNT] = [false; PROCESS_COUNT];
let mut q:Vec<u8> = Vec::with_capacity(PROCESS_COUNT); let mut q: Vec<u8> = Vec::with_capacity(PROCESS_COUNT);
while !done[0] || !done[1] || !done[2] || !done[3] || !done[4] while !done[0] || !done[1] || !done[2] || !done[3] || !done[4] {
{
infinite_detection -= 1; infinite_detection -= 1;
for i in 0..PROCESS_COUNT for i in 0..PROCESS_COUNT {
{
if !done[i] if !done[i]
&& a_remaining >= remaining_needs_matrix[i][0]
&& b_remaining >= remaining_needs_matrix[i][1]
&& c_remaining >= remaining_needs_matrix[i][2]
{ {
if a_remaing >= remaining_needs_matrix[i][0] && b_remaing >= remaining_needs_matrix[i][1] && c_remaing >= remaining_needs_matrix[i][2] match a_remaining.checked_sub(remaining_needs_matrix[i][0]) {
{ Some(result) => {
match a_remaing.checked_sub(remaining_needs_matrix[i][0]) a_remaining = result;
{
Some(result) =>
{
a_remaing = result;
} }
None => None => {
{
return (false , vec![]);
}
}
match a_remaing.checked_add(max_needs_matrix[i][0])
{
Some(result) =>
{
a_remaing = result;
}
None =>
{
return (false, vec![]); return (false, vec![]);
} }
} }
match b_remaing.checked_sub(remaining_needs_matrix[i][1]) match a_remaining.checked_add(max_needs_matrix[i][0]) {
{ Some(result) => {
Some(result) => a_remaining = result;
{
b_remaing = result;
} }
None => None => {
{
return (false , vec![]);
}
}
match b_remaing.checked_add(max_needs_matrix[i][1])
{
Some(result) =>
{
b_remaing = result;
}
None =>
{
return (false, vec![]); return (false, vec![]);
} }
} }
match c_remaing.checked_sub(remaining_needs_matrix[i][2]) match b_remaining.checked_sub(remaining_needs_matrix[i][1]) {
{ Some(result) => {
Some(result) => b_remaining = result;
{
c_remaing = result;
} }
None => None => {
{ return (false, vec![]);
return (false , vec![]);
} }
} }
match c_remaing.checked_add(max_needs_matrix[i][2]) match b_remaining.checked_add(max_needs_matrix[i][1]) {
{ Some(result) => {
Some(result) => b_remaining = result;
{
c_remaing = result;
} }
None => None => {
{ return (false, vec![]);
}
}
match c_remaining.checked_sub(remaining_needs_matrix[i][2]) {
Some(result) => {
c_remaining = result;
}
None => {
return (false, vec![]);
}
}
match c_remaining.checked_add(max_needs_matrix[i][2]) {
Some(result) => {
c_remaining = result;
}
None => {
return (false, vec![]); return (false, vec![]);
} }
} }
@ -271,11 +272,9 @@ fn banker(a:u8, b:u8, c:u8, max_needs_matrix:[[u8;RESOURCE_COUNT];PROCESS_COUNT]
infinite_detection = 2; infinite_detection = 2;
} }
} }
} if infinite_detection == 0 {
if infinite_detection == 0
{
return (false, q); return (false, q);
} }
} }
(true, q) (true, q)
} }