FilesExpand file tree

 master

/

FirstFit.java

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

72 lines (67 loc) · 2.85 KB

 master

/

FirstFit.java

Copy path

Top

File metadata and controls

• Code
• Blame

72 lines (67 loc) · 2.85 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

package Others;

import java.util.ArrayList;

/** @author Dekas Dimitrios */

public class FirstFit {

private static final int NO_ALLOCATION =

-255; // if a process has been allocated in position -255,

// it means that it has not been actually allocated.

/**

* Method to find the index of the memory block that is going to fit the given process based on

* the first fit algorithm.

*

* @param blocks: the array with the available memory blocks.

* @param process: the size of the process.

* @return the index of the block that fits, or -255 if no such block exists.

*/

private static int findFirstFit(int[] blockSizes, int processSize) {

for (int i = 0; i < blockSizes.length; i++) {

if (blockSizes[i] >= processSize) {

return i;

}

}

// If there is not a block that can fit the process, return -255 as the result

return NO_ALLOCATION;

}

/**

* Method to allocate memory to blocks according to the first fit algorithm. It should return an

* ArrayList of Integers, where the index is the process ID (zero-indexed) and the value is the

* block number (also zero-indexed).

*

* @param sizeOfBlocks: an int array that contains the sizes of the memory blocks available.

* @param sizeOfProcesses: an int array that contains the sizes of the processes we need memory

* blocks for.

* @return the ArrayList filled with Integers repressenting the memory allocation that took place.

*/

static ArrayList<Integer> firstFit(int[] sizeOfBlocks, int[] sizeOfProcesses) {

// The array list responsible for saving the memory allocations done by the first-fit algorithm

ArrayList<Integer> memAlloc = new ArrayList<>();

// Do this for every process

for (int processSize : sizeOfProcesses) {

int chosenBlockIdx =

findFirstFit(

sizeOfBlocks, processSize); // Find the index of the memory block going to be used

memAlloc.add(chosenBlockIdx); // Store the chosen block index in the memAlloc array list

if (chosenBlockIdx

!= NO_ALLOCATION) { // Only if a block was chosen to store the process in it,

sizeOfBlocks[chosenBlockIdx] -= processSize; // resize the block based on the process size

}

}

return memAlloc;

}

/**

* Method to print the memory allocated.

*

* @param memAllocation: an ArrayList of Integer representing the memory allocation done by the

* firstFit method.

*/

public static void printMemoryAllocation(ArrayList<Integer> memAllocation) {

System.out.println("Process No.\tBlock No.");

System.out.println("===========\t=========");

for (int i = 0; i < memAllocation.size(); i++) {

System.out.print(" " + i + "\t\t");

if (memAllocation.get(i) != NO_ALLOCATION) System.out.print(memAllocation.get(i));

else System.out.print("Not Allocated");

System.out.println();

}

}

}