RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-25 20:57:35 +00:00
Code Issues Activity Actions

Utilities/allocate: Modernize the code a bit

Browse source 
Use LibCore ArgsParser to parse the parameters instead of using the raw
strings from the argv (Main::Arguments) array.

Also, use indicative names for variables in the code so the utility code
is more understandable.
This commit is contained in:
Liav A 2023-06-25 21:52:47 +03:00 • committed by Jelle Raaijmakers
parent 75ae368896
commit b74cb569ec
2 changed files with 105 additions and 53 deletions
Download patch file Download diff file Expand all files Collapse all files

70
Userland/Utilities/allocate.cpp
View file

@ -1,81 +1,85 @@
/*
* Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
* Copyright (c) 2023, Liav A. <liavalb@hotmail.co.il>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#include <AK/Format.h>
#include <AK/Optional.h>
#include <LibCore/ArgsParser.h>
#include <LibCore/ElapsedTimer.h>
#include <LibMain/Main.h>
#include <unistd.h>
static void usage()
{
warnln("usage: allocate [number [unit (B/KiB/MiB)]]");
exit(1);
}
enum class Unit {
Bytes,
KiB,
MiB,
GiB,
};
ErrorOr<int> serenity_main(Main::Arguments arguments)
{
int count = 50;
auto unit = Unit::MiB;
size_t iterations_count = 10;
size_t allocation_size = 100;
auto unit = Unit::Bytes;
StringView chosen_unit {};
if (arguments.argc >= 2) {
auto number = arguments.strings[1].to_uint();
if (!number.has_value()) {
usage();
}
count = number.value();
}
Core::ArgsParser args_parser;
args_parser.add_option(chosen_unit, "Allocation's Size Unit in base 2 (B, KiB, MiB, GiB)", "unit", 'u', "unit");
args_parser.add_option(iterations_count, "Number of seconds to sleep before freeing memory", "sleep-time", 'n', "seconds");
args_parser.add_positional_argument(allocation_size, "Allocation Size", "size", Core::ArgsParser::Required::No);
args_parser.parse(arguments);
if (arguments.argc >= 3) {
if (arguments.strings[2] == "B")
if (!chosen_unit.is_null()) {
if (chosen_unit == "B"sv) {
unit = Unit::Bytes;
else if (arguments.strings[2] == "KiB")
} else if (chosen_unit == "KiB"sv) {
unit = Unit::KiB;
else if (arguments.strings[2] == "MiB")
} else if (chosen_unit == "MiB") {
unit = Unit::MiB;
else
usage();
} else if (chosen_unit == "GiB") {
unit = Unit::GiB;
} else {
args_parser.print_usage(stderr, arguments.strings[0]);
return 1;
}
}
switch (unit) {
case Unit::Bytes:
break;
case Unit::KiB:
count *= KiB;
allocation_size *= KiB;
break;
case Unit::MiB:
count *= MiB;
allocation_size *= MiB;
break;
case Unit::GiB:
allocation_size *= GiB;
break;
}
outln("allocating memory ({} bytes)...", count);
outln("allocating memory ({} bytes)...", allocation_size);
auto timer = Core::ElapsedTimer::start_new();
char* ptr = (char*)malloc(count);
auto* ptr = reinterpret_cast<char*>(malloc(allocation_size));
if (!ptr) {
outln("failed.");
return 1;
}
outln("done in {}ms", timer.elapsed_milliseconds());
auto pages = count / PAGE_SIZE;
auto step = pages / 10;
size_t pages_count = allocation_size / PAGE_SIZE;
auto step = pages_count / 10;
outln("writing one byte to each page of allocated memory...");
timer.start();
auto timer2 = Core::ElapsedTimer::start_new();
for (int i = 0; i < pages; ++i) {
ptr[i * PAGE_SIZE] = 1;
for (size_t page_index = 0; page_index < pages_count; ++page_index) {
ptr[page_index * PAGE_SIZE] = 1;
if (i != 0 && (i % step) == 0) {
if (page_index != 0 && (page_index % step) == 0) {
auto ms = timer2.elapsed_milliseconds();
if (ms == 0)
ms = 1;
@ -89,9 +93,9 @@ ErrorOr<int> serenity_main(Main::Arguments arguments)
}
outln("done in {}ms", timer.elapsed_milliseconds());
outln("sleeping for ten seconds...");
for (int i = 0; i < 10; i++) {
outln("{}", i);
outln("sleeping for {} seconds...", iterations_count);
for (unsigned iteration_index = 0; iteration_index < iterations_count; iteration_index++) {
outln("{}", iteration_index);
sleep(1);
}
outln("done.");