DEV Community: ta-lim

Concurrency Problems

ta-lim — Thu, 13 Apr 2023 15:46:21 +0000

Competition for resources and two common problems that arise due to competition in computer processes can be a bit challenging to comprehend. When two or more processes compete for the same resources, such as I/O equipment, memory, clock, and others, without any information exchange mechanism between the processes, it can cause problems. As a result, the rejected process will slow down, and sometimes, a blocked process may occur, never accessing the resource.

The problems that arise from competition in computer processes can be categorized into two types: the Producer-Consumer Problem and the Reader-Writer Problem. The Producer-Consumer Problem occurs when there are two or more processes interacting using the same buffer, with one process acting as a Producer (adding value to the buffer), and another process acting as a Consumer (taking/reducing the buffer's contents).

One type of issue that arises from competition among computer processes is the Producer-Consumer Problem, which occurs when two or more processes interact using the same buffer, with one process acting as a producer (adding values to the buffer) and another acting as a consumer (removing/reducing the buffer's contents). In order to overcome this problem, requirements such as regulating the critical section, limiting access to the same resource, and halting production or consumption when the buffer is full or empty, must be met.

Another type of issue that can arise from competition among computer processes is the Reader-Writer Problem, which occurs when multiple processes read (reader) the same data at the same time. To overcome this problem, requirements such as allowing two or more readers to read data simultaneously, preventing any reader from reading data while the writer is writing data, and ensuring that the writer waits for all readers to finish reading data, must be met. Techniques such as mutual exclusion, semaphore, monitor, and lock can be used to address competition among computer processes and overcome these issues.

Meanwhile, the Reader-Writer Problem occurs when several processes read (reader) the same data simultaneously. The requirements to overcome this problem are that two or more readers can read data together, no reader can read data when data is being written by the writer, and the writing process must wait for all readers who are reading data to finish reading.

To solve the problem of competition in computer processes, there are several techniques that can be used, such as mutual exclusion, semaphore, monitor, and lock. The mutual exclusion technique is used to limit access to the same resources. The semaphore is used for synchronization between processes, where there is a flag or token setting indicating whether the resource is being used or not. Monitors and locks are also used to ensure that accessing the same resources does not occur simultaneously.

For solution

1. Mutual Exclusion

condition where only one process or thread can access a particular resource at a given time. This is necessary to prevent errors when multiple processes or threads attempt to access the same resource simultaneously. For example, when two processes try to change the same data at the same time, it can cause damage to the data. To prevent this, only one process or thread can access the resource at a given time.

Mutual Exclusion can be handled using locking techniques. Locking allows processes or threads to hold a key or token to access a particular resource. If the resource is already locked by a certain process or thread, other processes or threads cannot access it until the key or token is released. This technique ensures that only one process or thread can access the resource at a given time, thereby preventing errors and data corruption.

2. Deadlock

condition where two or more processes are waiting for each other to release the required resources. As a result, no process can complete its task, and the program gets stuck in a dead state. This can happen if each process holds the resource required by another process, so no one can release the resource. To avoid deadlock, the operating system can use algorithms to detect and prevent such conditions.

Deadlock can be handled by using algorithms to detect and prevent the condition. One commonly used algorithm is the Banker's Algorithm. This algorithm ensures that a process can only start if all the required resources are available and will not cause deadlock. Additionally, if a deadlock is detected, the operating system can force processes to release the resources they have taken or perform a system restart to avoid deadlock.

3. Starvation

condition where a process or thread cannot access the required resources to complete its task because the resources are always being used by other processes or threads. This can happen if the operating system does not prioritize certain processes or threads, allowing some to keep using the same resources while others do not have access to those resources. To avoid starvation, the operating system can use algorithms to ensure that each process or thread gets access to the resources it needs to complete its task.

Starvation can be handled using priority techniques. In an operating system, processes or threads can be prioritized based on their urgency or importance in completing a task. This technique ensures that the most important processes or threads get access to the resources they need to complete their tasks first, thereby preventing processes or threads from being constantly blocked and experiencing starvation.

4. Data coherence

condition where the same data stored in multiple locations maintains the same integrity and consistency. In a multi-process or multi-thread environment, where several processes or threads can access the same data, data coherence is crucial to prevent conflicts and errors in data. The operating system uses data coherence techniques such as cache consistency protocols and time-based access control to ensure that all processes or threads always see the same version of the data they are using.

Data coherency can be handled using cache consistency protocols. These protocols ensure that every process or thread always sees the same version of the data they are using, even if the data is stored in multiple locations. Additionally, time-based access control can be used to ensure that every process or thread that needs access to the data gets access in the correct order, thereby preventing errors and conflicts on the data.

Command Management Process and Thread in UBUNTU

ta-lim — Fri, 17 Mar 2023 02:52:31 +0000

Managing service

service <service_name> <action>

Example:
service sshd status

service sshd start

service sshd stop

Where is the name of the system service you want to manage, and is the action you want to perform on the service (such as start, stop, restart, enable, or disable).

In addition to the basic syntax, the service command also supports several attributes or options that can be used to customize its behavior. Some of the most commonly used attributes include:

status-all: This attribute displays the status of all system services, whether they are currently running or not.
reload: This attribute reloads the configuration file for a service without actually stopping and restarting the service.
full-restart: This attribute performs a full restart of a service, which involves stopping and then starting the service again.
list: This attribute lists all available system services that can be managed with the service command.

Running Init

/etc/init.d/[servie] [command]
the /etc/init.d command in Linux is a directory containing scripts used to start, stop, and restart system services on the system. These scripts can be run directly using specific arguments, or using the service command, which provides a simpler interface for managing system services.

Example:
/etc/init.d/ssh start
/etc/init.d/ssh stop
/etc/init.d/ssh restart
/etc/init.d/ssh status

Top

top
The purpose of the top command is to provide an easy-to-use interface for monitoring and managing running processes on a Linux system. It can be used to identify resource-intensive processes, find out which processes are consuming the most system resources, and terminate or suspend processes as needed.

description of each column in the table output:

PID: The process ID of the task.
USER: The user who started the process.
PR: The priority of the process.
NI: The "nice" value of the process, which determines its priority in the scheduling queue.
VIRT: The total amount of virtual memory used by the process.
RES: The amount of physical memory used by the process.
SHR: The amount of shared memory used by the process.
S: The process state. It can be R (running), S (sleeping), D (disk sleep), Z (zombie), or T (stopped).
%CPU: The percentage of CPU time used by the process since the last update.
%MEM: The percentage of physical memory used by the process.
TIME+: The total CPU time used by the process since it started.
COMMAND: The command that started the process.

Some of the key attributes of the top command include:

Process List: The main display of the top command is a list of all the processes running on the system, along with detailed information about each process, such as the process ID (PID), user, CPU usage, memory usage, and more.
Resource Consumption: The top command provides real-time information about the system's resource usage, including CPU usage, memory usage, and system uptime. This information is displayed both as overall statistics for the entire system and as individual statistics for each process.
Sorting Options: The top command allows users to sort the process list based on a variety of criteria, such as CPU usage, memory usage, process ID, and more. This makes it easy to identify resource-intensive processes and take action as needed.
Interactive Features: The top command is an interactive tool that allows users to manipulate the process list in real-time. For example, users can suspend or resume processes, change the priority of running processes, and more.

Process and Thread

ta-lim — Fri, 17 Mar 2023 02:30:15 +0000

Summarize from Youtube Videos

Process Management (Processes and Threads) (Youtube)

Process

A process is an instance of a program that is currently being executed. It is an independent entity that consists of an address space, a set of data structures, and one or more threads of execution. The state of a process can be represented by various states, such as running, ready, waiting, and terminated. Process models can vary, but common ones include the parent-child model and the peer model.

On Unix systems, processes are represented by process IDs (PIDs) and can be managed using various system calls and commands, such as fork(), exec(), kill, and ps.

Main Requirements of Process Control

Concurrent execution: the ability of the operating system to run multiple processes simultaneously.
Sharing resources: processes can share resources such as memory, CPU, and I/O devices.
Independent address space: each process has a separate memory address to prevent one process from corrupting the memory of another process.

Process State

The process state reflects the state of the process in its life cycle. There are several commonly known process states, including:

New: the process is in the process of being created.
Ready: the process is ready to be executed by the CPU.
Running: the process is currently being executed by the CPU.
Blocked: the process cannot run because it is waiting for a resource or external input.
Terminated: the process has finished executing.

Process Creation and Termination

Creation

Processes are created when a program starts or when a program requests to create a new process. A new process has a unique identity in the operating system, including a process ID (PID), address space, and PCB.

Termination

Processes can end for a number of reasons, such as completing execution, being stopped by the operating system, or experiencing failure during execution. When a process ends, the operating system will clean up the resources used by the process, including memory and open files. Processes can also be forcibly stopped by the operating system in certain situations, such as if the process accesses unauthorized memory or if the process experiences a deadlock.

Events that can trigger the creation and termination of a process

Events that Trigger Process Creation	Events that Trigger Process Termination
User request	Normal completion
System initialization	Error
Interrupts	Killed by another process
Fork system call	User intervention
Exec system call	System shutdown

Model Process

Two-state model

Simple model that describes a system or process that can exist in one of two states. These two states are typically referred to as "on" and "off", "up" and "down", or "working" and "not working", depending on the context of the system or process being described.

The two-state model is commonly used in various fields such as electronics, mechanics, and computer science. For example, a light switch can be considered a two-state model, as it can be either "on" or "off". Similarly, a computer network connection can be considered a two-state model, as it can be either "connected" or "disconnected".

The simplicity of the two-state model makes it useful for modeling and analyzing systems that can be described in binary terms. However, it may not be suitable for more complex systems that require more nuanced descriptions of state.

Five-state model

five-state model is a common model used to describe the various states that a process can be in during its lifecycle. The five states are as follows:

New: This is the initial state of a process, where the process is being created.
Ready: In this state, the process is waiting to be assigned to a processor. It is loaded into main memory and is ready to run, but the CPU is currently executing another process.
Running: In this state, the process has been assigned to a processor and is currently executing its instructions.
Blocked (Waiting): In this state, the process is waiting for an event to occur or for a resource to become available. For example, it may be waiting for user input, waiting for I/O operations to complete, or waiting for a signal from another process.
Terminated (Exit): In this state, the process has finished its execution and is being removed from the system. The process releases any resources it was using, and its PCB is deleted from the system.

Two-Level Model

The Two-Level Model is a process state model that divides process states into two levels: User Level and Kernel Level. The User Level states, which include Running, Ready, and Blocked, are managed by the process scheduler. Running is the state of a process that is currently executing on the CPU, while Ready is the state of a process that is waiting to be assigned to the CPU. Blocked is the state of a process that is waiting for an event to occur, such as the completion of an I/O operation.

The Kernel Level states, which include Interrupted, Waiting, and Zombie, are managed by the operating system kernel. Interrupted occurs when a process is interrupted by a hardware event, such as a timer interrupt. Waiting occurs when a process is waiting for a resource, such as I/O, to become available. Zombie occurs when a process has completed its execution, but its exit status has not yet been retrieved by its parent process.

The Two-Level Model provides a clear separation between user-level states and kernel-level states. This allows for efficient management of processes and resources, as the operating system can focus on managing the kernel-level states while leaving the user-level states to be managed by the process scheduler. The model also allows for easy implementation of process synchronization and communication mechanisms.

Description:

-Created-Process is newly created by system call, is not ready to run

User running-Process is running in user mode which means it is a user process.
Kernel Running-Indicates process is a kernel process running in kernel mode.
Zombie- Process does not exist/ is terminated.
Preempted- When process runs from kernel to user mode, it is said to be preempted.
Ready to run in memory- It indicated that process has reached a state where it is ready to run in memory and is waiting for kernel to schedule it.
Ready to run, swapped– Process is ready to run but no empty main memory is present
Sleep, swapped- Process has been swapped to secondary storage and is at a blocked state.
Asleep in memory- Process is in memory(not swapped to secondary storage) but is in blocked state.

Some Related Terms

Process: A program that is currently running on a computer.
Thread: A sub-part of a process that can be scheduled independently by the operating system.
Process Control Block (PCB): A data structure used by the operating system to store information about a process, including information about the process state, status registers, and pointers to the memory used by the process.
Trace: A component of the operating system responsible for monitoring process activity.
Dispatcher: A component of the operating system responsible for allocating CPU time to the process selected by the scheduler.

Threads

A thread is a separate path of execution within a process. It shares the same memory space and resources as the process that it belongs to. Threads can improve performance and responsiveness of a program, especially in systems with multiple CPUs or cores.

Advantages of Using Threads:

A thread is the basic unit of parallel processing that allows multiple tasks to be executed simultaneously within a program. Some advantages of using threads in programming include:

Improving Program Responsiveness: By using threads, a program can respond to inputs and events faster, thus improving program speed and performance.
Simplifying Programming: In some cases, using threads can simplify the programming process by allowing for separate and parallel management of different tasks.
Improving Resource Efficiency: Threads can help improve the use of computer resources, such as CPU and memory, by allowing multiple tasks to be executed simultaneously.

Single Threading Approach

The single threading approach uses only one thread to execute a program. In this approach, tasks are processed serially and one by one. The weakness of this approach is that it is less effective in utilizing computer resources because it uses only one thread.

Multi-Threading Approach

The multi-threading approach allows for the use of multiple threads simultaneously within a program. With this approach, tasks can be processed in parallel, thus improving program efficiency and responsiveness.

Processes in the Multithreading Perspective

In the multithreading perspective, a process can have several threads working on different tasks simultaneously. These threads can communicate and share resources, such as memory and CPU, to complete the given tasks.

Multicore and Multithreading

Multicore is a technology that uses multiple cores on a CPU to improve computer performance. In combination with multithreading, the use of multicore technology can improve program efficiency and performance by allowing threads to be run on different cores.

Applications Benefiting from Multicore Concept:

The multicore and multithreading concepts can be applied to various types of programs, such as programs that process images, videos, or audio, programs that perform intensive calculations, and programs that require real-time interaction. In these applications, this concept can significantly improve program performance and efficiency.

Image and video processing software
Audio editing and recording software
3D modeling and animation software
Scientific simulation software
Financial modeling and analysis software

the differences between processes and threads

	Processes	Threads
Definition	A program in execution, consisting of an executable file and associated resources such as memory, system files, and I/O devices.	A lightweight process that can execute concurrently with other threads within the same process.
Resource ownership	Each process has its own set of system resources, including memory, file descriptors, and sockets.	All threads within a process share the same set of system resources, including memory and file descriptors.
Communication	Processes typically communicate with each other using interprocess communication (IPC) mechanisms, such as pipes, sockets, or message queues.	Threads can communicate with each other by directly accessing shared data within the same process.
Scheduling	Processes are scheduled and managed by the operating system kernel, which assigns each process a priority and time slice.	Threads are scheduled and managed by the operating system kernel or by the process itself, depending on the threading model used.
Creation	Processes are typically created using the fork() system call, which creates a copy of the parent process.	Threads are created within a process using a thread library or a system call, such as pthread_create() on Unix-based systems.
Overhead	Creating a new process incurs a significant amount of overhead, including memory allocation and copying of resources from the parent process.	Creating a new thread is much faster than creating a new process, as the new thread shares the same resources as the parent process.
Isolation	Processes are fully isolated from each other, meaning that a bug or crash in one process does not affect other processes.	Threads share the same address space, so a bug or crash in one thread can affect the entire process.
Scalability	Processes are less scalable than threads, as they require more system resources and have higher overhead.	Threads are more scalable than processes, as they can take advantage of multiple CPUs and have lower overhead.

Several to management in LINUX UBUNTU

Management File

ta-lim — Thu, 02 Mar 2023 02:45:32 +0000

File Management

Is the process of managing and storing data on storage devices such as magnetic disks, magnetic tapes, and optical disks.

Types of files

that can be stored include numeric data, character data, binary data, as well as programs such as source programs, object programs, and executable programs.

The tasks and functions of file management

a. Meeting the needs of data management and users.
b. Ensuring data validity.
c. Optimizing system performance and user response time.
d. Providing I/O support for data storage devices.

File management is also responsible for:

a. Minimizing the possibility of data loss or damage.
b. Providing standard I/O interfaces.
c. Providing I/O support for multiple users.
d. Creating, modifying, and deleting files.

Additionally, file management must provide mechanisms for:

Concurrent file usage.
b. Data backup and recovery.
c. Maintaining the confidentiality and security of information.
d. Providing a user-friendly interface for users.

Table of differences between FAT and NTFS

Feature	FAT	NTFS
File and folder access	No complex permissions	Complex permissions with different levels of access
Journaling	No	Yes
Partition size	Up to 32 GB	Up to several terabytes
File and folder encryption	No	Yes (using EPS)
File compression	No	Yes
Deleted file recovery	Third-party software required	Built-in feature for internal recovery
Symbolic links	Not supported	Supported (symbolic link, hard link, and junction)
Reliability	More prone to corruption and requires more time to check and fix errors	More resilient and has mechanisms for automatic partition error fixing

Note

that the decision to use FAT or NTFS depends on specific usage needs and conditions. If you only need a small partition to store files or data, FAT may be a good choice. However, if you require advanced features such as encryption and complex permissions, NTFS may be a better choice.

Table comparing Structured Tree Directory and Acyclic Graph Directory

Feature	Structured Tree Directory	Acyclic Graph Directory
Structure	Uses a tree structure	Uses a graph structure
Files and Directories	Does not allow files and directories to be used together	Allows files and directories to be used together
Path Names	Each file has a unique path name	The same file or subdirectory may exist in multiple directories
Security	More secure since files and directories cannot be used together	More vulnerable since files and directories can be used together and exist in multiple directories
Simplicity	More simple since it uses a tree structure	More complex since it uses a graph structure and allows files and directories to be used together
Usage	Suitable for systems that require security and clear structure organization	Suitable for systems that require flexibility and the ability to use files and directories together

Note

the decision to use either directory structure depends on the specific needs and purposes of the system.

Operations on files and directories

1. Create

Create a new directory using the command: $ mkdir Example:

$ mkdir Latihan or $ mkdir latihan1 latihan2 latihan3

Create a directory with subdiectories using the command: $ mkdir –p // Example:

$ mkdir –p OS/pratikum1/tugas1

Create an empty file using the command: $ touch Example:

$ touch file1 file2 file3 file4

Create an empty file with a specific extension using the command: $ touch . Example:

$ touch file1.txt

2. Write

Write content to a file using an editor such as Nano or Vim. Example:

$ nano file1

Write content to a file using the echo command: $ echo “text” > Example:

$ echo “isi konten di sini” > draft

3. Read

To read the contents of a file, use the command "cat "
Example:

$ cat draft

4. Delete

To remove a file, use the command "rm " Example:

$ rm fill1

If you want to remove a directory, make sure the directory is empty, and then use the command "rmdir " Example:

$ rmdir latihan3

If you want to remove a directory and its contents recursively, use the command "rm -r " Example:

$ rm -r /home/ta-lim/kuliah/SO/pratikum1/tugas1

5. Reposition

Searching files or directories can be done using the "find" command Files can be searched based on their name, type, or time
Examples:

$ find . -name "text"
$ find . -name latihan_nengok

The "locate" command can also be used for searching, with examples like:

$ locate <keyword>
$ locate -i latihan

6. Truncate

Truncate is used to change the size of a file without changing its attributes
The file is resized to zero but still remains available
The "truncate" operation can be done using

the command: truncate –s <requested size> <filename>
Example: truncate –s 0 file1

Partial content can be deleted without opening the file itself
Example: file1 becomes zero-sized without deleting the file or its contents

File and directory manipulation

- View directory listings

Use the command $ pwd to know the current directory

Use the command $ cd to change directory, for example $ cd ta-lim

Use the command $ cd ..to move to the previous directory

Use the command $ cd / to move to the root directory

Use the command $ ls to view the contents of the directory

Use the command $ ls -l to view the contents of the directory in list format

Use the command $ ls -a to view the contents of the directory including hidden files and directories

Use the command $ ls -aL to view the contents of the directory recursively

- Copy and Move files/directories

Use the command

$ cp <file name> <destination directory>
$ cp tugaskuliah /home/ta-lim/kuliah/SO

to copy files/directories

Use the command

$ mv <file name> <destination directory>

to move files/directories or rename files/directories

- Recursion on files and directories

In the context of delete operations, we discussed how to delete an empty directory in a previous discussion.
Now, we will discuss how to delete a directory that still contains files inside. This requires a recursive approach.Recursion is a problem-solving method where the solution depends on another solution that is smaller in scope and part of the same problem.
To delete files, directories, and subdirectories recursively, we use the command: $ rm -r (in some cases, root access may be required).

The -r option is used to delete files recursively. For example, to delete the file tugas1 that we previously created, we can run the command and see that the tugas1 folder and its contents have been deleted successfully.

Use the command $ rm <file name> to delete files
Use the command

$ rm -r <directory name>
$ rm -r /home/ta-lim/kuliah/SO/pratikum1/tugas1

to delete directories recursively

Access rights

Access rights on Ubuntu Server can be configured through ownership, permission, and group settings on files or directories. Here is a summary of access rights on Ubuntu Server:

Ownership

Each file or directory has an owner (user) and an owning group (group).The owner can access and modify the file or directory, and the owning group can have certain access rights.Ownership can be set using the $ chown and $ chgrp commands.

Permission

Each file or directory has three types of access rights: read, write, and execute. Access rights can be granted to the owner, owning group, and other users.Permissions can be set using the $ chmod command.

Group

Files or directories can be grouped into a group, and access rights can be granted to that group. Users can be added to a group to gain certain access rights.Group settings can be configured using the $ addgroup and $ usermod commands.

Superuser (root)

The superuser has full access rights to the system.Users with superuser access can configure access rights for other users and the system as a whole. Users can use the $ sudo command to gain access as the superuser.

Change file or directory permissions

Use the chmod command with the format $ chmod [mode][file/directory]. The mode can be in numeric notation (e.g. 744) or symbolic notation (e.g. rwxr--r--).The numeric and symbolic notations represent the permissions for owner, group, and others, each with a value of 0-7. The order of the permissions is read (r), write (w), and execute (x).

Example:$ chmod 744 Latihan or $ chmod u=rw,g=r,o=r Latihan
(give read-write permission to owner and read-only permission to group and others)

Changing Ownership of Files and Directories

Use the chown command with the format $ chown [owner]:[group] [file/directory].
Owner is the name of the new owner and group is the name of the new group.

    Example: $ chown lim:lim Latihan 
(change the owner to john and the group to users)

Example Case

In a job interview for a System Administrator position, you are asked to create two users that represent your identity (e.g. user1=first name; user2=last name). For each user, create a directory named Ujian1 (user1) and Ujian2 (user2). Then, create 3 files with a size of 100 bytes simultaneously in the Ujian1 directory, and create 3 files with a size of 200 bytes simultaneously in the Ujian2 directory. Swap the ownership of the Ujian1 directory to User2 and vice versa. Then, set the access permission of one file (of your choice) to be readable only by the user and group who own the file, but not readable by other users.

Create User, Directory, and File

$ sudo adduser muhamad (user1)
$ sudo adduser talim (user2)

$ mkdir Ujian1 (user muhamad)
$ mkdir Ujian2 (user talim)

$ touch soal4 soal5 soal6 (user muhamad) 
$ touch soal1 soal2 soal3 (user talim)

$ truncate -s 100 soal4 soal5 soal6
$ truncate -s 100 soal1 soal2 soal3

Swap the ownership directory

The "chown" command in Linux is used to change the ownership of files and directories. Only the root user or a user with sudo privileges can change the ownership of a file or directory. This is because changing ownership can have significant security implications, and only privileged users should be able to make such changes.

When a file or directory is created, it is assigned an owner and a group. The owner is the user who created the file or directory, and the group is a set of users who have access to the file or directory. The "chown" command allows you to change the owner and group of a file or directory to any other user or group on the system, as long as you have the necessary permissions.

$ sudo chown talim Ujian1 (set access in dir Ujian1 to user talim)
$ sudo chown muhamad Ujian2 (set access in dir Ujian2 to user muhamad)

Set access for a file

$ chmod 440 soal1

Reference

Difference between FAT32 and NTFS
Structures of Directory in Operating System

Instalasi Ubuntu Server di Virtual Box Manager

ta-lim — Wed, 15 Feb 2023 09:12:48 +0000

Untuk tugas mata kuliah sistem operasi

Unduh file ISO Ubuntu Server dari situs web resmi Ubuntu
Unduh aplikasi Virtual Box Manager
Buka VirtualBox dan klik "New" untuk membuat mesin virtual baru.
Pada layar "Name and Operating System", masukkan nama untuk mesin virtual dan pilih "Linux" sebagai tipe sistem operasi, dan "Ubuntu (64-bit)" sebagai versinya.
Pada layar "Base Memory", alokasikan jumlah RAM yang ingin Anda berikan ke mesin virtual. Disarankan untuk mengalokasikan setidaknya 1 GB RAM. (pada gambar mengalokasikan sebesar 2 GB RAM)
Pada layar "File location and size", masukkan nama untuk file hard disk virtual, pilih lokasi untuk menyimpannya, dan alokasikan jumlah ruang hard disk yang ingin Anda berikan ke mesin virtual. Disarankan untuk mengalokasikan setidaknya 10 GB ruang hard disk.(Pada gambar mengalokasikan sebesar 20 GB)
Pada tampilan Summary klik "Finish" untuk membuat mesin virtual.
Di VirtualBox Manager, pilih mesin virtual yang baru saja Anda buat dan klik "Settings".
Pada jendela "Settings", klik "Storage" dan kemudian "Empty" di bawah "Controller: IDE".
Klik pada ikon "CD/DVD" dan kemudian "Choose Virtual Optical Disk File".
Telusuri file ISO Ubuntu Server yang Anda unduh pada langkah 1 dan pilih file tersebut.
Klik "OK" untuk menutup jendela "Settings".
Mulai mesin virtual dengan mengklik tombol "Start" di VirtualBox Manager.
Ikuti petunjuk instalasi Ubuntu Server untuk menyelesaikan instalasi.
Berikut tampilan akhir pada VirtualBox Manager setelah instalasi Ubuntu server telah selesai