WO2016060700A1

WO2016060700A1 - File system journaling

Info

Publication number: WO2016060700A1
Application number: PCT/US2014/067967
Authority: WO
Inventors: Anton Ajay MENDEZ; Mohan GOVINDARAJ; Sandya Srivilliputtur Mannarswamy
Original assignee: Hewlett Packard Enterprise Development Lp
Priority date: 2014-10-17
Filing date: 2014-12-01
Publication date: 2016-04-21

Abstract

The present subject matter relates to file system journaling. In one example upon occurrence of a journal flushing event, a journal working set size is compared with a dynamic journaling threshold. The journal working set size indicates size of aggregated journal entries stored in main memory of a computing system. Further, the aggregated journal entries include a new journal entry created in response to the journal flushing event. Further, the dynamic journaling threshold is based on size of unused space of the main memory. It is further determined whether aggregated journal entries stored in the main memory have to be flushed to a journal in a storage device of the computing system based at least on the comparing. The aggregated journal entries are flushed from the main memory to the journal in the storage device based on the determining.

Description

FILE SYSTEM JOURNALING

BACKGROUND

[0001] Increasing use of data processing and data generation in enterprises produces ever-increasing amounts of data which are stored for short, medium, or long periods. Such data may be used by the organization for carrying out one or more operations. Enterprises generally implement data management and file storage systems for managing such data, such as data logs and files. Generally, storing the information using a file system involves performing file related actions such as creating a file, adding information in the file, deleting or archiving the file, and setting permissions for the file. The file systems further maintain a journal or a log which contains sequence of file system actions, such as file creation and metadata modification performed by the file system.

BRIEF DESCRIPTION OF FIGURES

[0002] The detailed description is described with reference to the accompanying figures. In the figures, the left-most digit(s) of a reference number identifies the figure in which the reference number first appears. The same numbers are used throughout the figures to reference like features and components. Systems and/or methods, in accordance with examples of the present subject matter are now described, by way of example, and with reference to the accompanying figures, in which:

[0003] Fig. 1A illustrates a block diagram of an example system for file system journaling, in accordance with an example of the present subject matter. [0004] Fig. 1 B illustrates various example components of the example system for file system journaling, in accordance with an example of the present subject matter.

[0005] Fig. 2 illustrates an example method for file system journaling, in accordance with an example of the present subject matter. [0006] Fig. 3 illustrates another example method for file system journaling, in accordance with an example of the present subject matter.

[0007] Fig. 4 illustrates another example method for file system journaling, in accordance with an example of the present subject matter.

[0008] Fig. 5 illustrates an example network environment implementing a non-transitory computer readable medium for file system journaling, according to an example of the present subject matter.

DETAILED DESCRIPTION

[0009] Systems and methods for file system journaling are described herein. The methods can be implemented in various systems, such as computing devices connected through various networks.

[0010] A file system may be understood as an abstraction implemented onto disk storage for organizing and storing data, stored as files. Each of the files stored within the file system may be further associated with metadata. The metadata may include, inode number, attributes, number of blocks, file size, file type, block map information, and the like. The file system may also facilitate in controlling the manner in which the data, such as a file is stored, modified, or retrieved from the disk storage. Such file related actions may be carried out by one or more applications which may be deployed on a computing system onto which the file system is implemented. Generally, when an application modifies the file, for example, by adding new content to the file data, metadata related to the file may also get modified. For instance, addition of the new content increases the file data size, owing to which new blocks may be allocated for the file. The file system may thus modify the metadata to update the addition of the block.

[0011] To facilitate an error-free file modification, file systems generally maintain a journal, also referred to as a transaction log, which includes a list of modification actions performed by the file system. A modification action may include changes made by a file system to a file such that metadata of the file is modified. Before the file system makes such changes, the file system creates a journal entry in the transaction log that includes a list of the modification actions the file system is about to perform. In case the computing system crashes before the modification actions are completed, the journal may be used to determine incomplete modification actions pending for completion. Once all the steps associated with the modification action are completed on the storage device, the modification action is considered as completed.

[0012] Each modification action performed during a file system operation is generally recorded in the journal as an individual journal record. Creating journal records for each modification action, however, increases number of journal records in the disk storing the journal, thus increasing the memory usage. Further, creating journal records for each modification action leads to an increase in a number of input/output (I/O) transactions performed by the file system for storing the journal records in the disk. A method of journal aggregation may thus be used to reduce the number of journal records and the I/O transactions. Journal aggregation includes aggregating different modification actions as journal entries before storing the modification actions in a single journal record upon completion of the file system operation. The aggregation may be affected within a volatile memory, such as a random access memory (RAM) of the computing device supporting the file system. The aggregated journal entries are generally stored in the disk either after a predetermined time or upon receiving a user instruction for flushing the journal entries. Further, the journal entries are marshaled into contiguous chunks before being written to the journal.

[0013] Although, journal aggregation reduces the number of journal records and the I/O transactions, journal aggregation increases the memory, i.e., RAM, consumption as the journal entries are stored in the RAM before being recorded in the journal. Further, the journal aggregation may cause an increase in memory pressure, i.e., performance pressure on the computing device due to memory crunch in resource constrained situations. For example, in cases of high memory usage by operations currently running on the computing device, an operating system of the computing device may try to free memory space by flushing the file system cache. In case, the file system cache includes journal entries that are being stored for journal aggregation, the file system would try to flush the journal entries of the journal. Flushing the journal entries would, however, involve allocation of additional memory space for marshaling the journal entries in the contiguous chunks before being written to the journal, thus increasing the memory pressure. Thus, the operating system's attempt to free memory space may cause a further increase in the memory pressure thus resulting in a probable deadlock, causing the computing device to slow down.

[0014] The present subject matter, describes a system and a method for file system journaling. The present subject matter facilitate in minimizing memory pressure caused due to journal aggregation by maintaining a journal working set size below a dynamic journaling threshold. The aggregated journal entries are automatically flushed in the journal upon crossing the dynamic journaling threshold. The journal working set size defines the amount, i.e., size of aggregated journal entries that are stored in main memory, such as RAM at a given time before being flushed in the journal. The dynamic journaling threshold defines a predefined percentage of size of unused space of the main memory. Flushing the aggregated journal entries based on the dynamic journaling threshold ensures that a considerable size of the unused space of the main memory is available for applications running on the system.

[0015] In accordance to an example of the present subject matter, a file system ascertains whether a journal flushing event has occurred. In one example, the journal flushing event is receipt of one of a new transaction indication and a flush cached pages request by a file system. The new transaction indication indicates modification of metadata of a file stored in the system. The flush cached pages request is a request from an operating system of a computing device for flushing cached pages present in the main memory. In case the journal flushing event is receipt of the new transaction indication, a new journal entry corresponding to the modifications may be added to the aggregated journal entries.

[0016] Upon the occurrence of the journal flushing event, a determination is made to ascertain whether the aggregated journal entries stored in the main memory have to be flushed to the journal. In one example, the determination is made based on the journal working set size and the dynamic journaling threshold. In order to ascertain whether the flushing is required or not, the journal working set size is compared with the dynamic journaling threshold. In case the journal working set size is greater than the dynamic journaling threshold, the aggregated journal entries are flushed to the journal. As a result, memory space of the main memory becomes free. [0017] In case the journal working set size is less than the dynamic journaling threshold, a predefined action is taken based on the journal flushing event. If the journal flushing event is receipt of the new transaction indication, the predefined action may include requesting a memory subsystem for allocation of main memory space for storing the new journal entry. If the journal flushing event is receipt of the flush cached pages request, the predefined action may include continuing tracking modification of metadata of the files stored in the system.

[0018] The present subject matter thus facilitates in minimizing memory pressure caused due to journal aggregation. As will be understood based on the above description, the memory pressure is minimized by flushing the aggregated journal entries as soon as the working set size becomes greater than the dynamic journaling threshold. Flushing the aggregated journal entries based on the dynamic journaling threshold ensures that the aggregated journal entries consume minimal space in the main memory. Controlling space occupancy by the aggregated journal entries ensures that a considerable size of the unused space of the main memory is available for applications running on the system. Thus, in cases of high memory usage by operations currently running on the computing system, the operating system may free space in the main memory by flushing file system cache without further increasing the memory pressure. The memory pressure in such cases is controlled as flushing the aggregated journal entries doesn't utilize much memory space since the working set size is maintained below the dynamic journaling threshold.

[0019] The systems and methods are further described in conjunction with Fig. 1 to Fig. 5, as examples of the present subject matter. It should be noted that the description and figures merely illustrate the principles of the present subject matter. It will thus be appreciated that various arrangements that embody the principles of the present subject matter, although not explicitly described or shown herein, can be devised from the description and are included within its scope. Furthermore, all examples recited herein are for pedagogical purposes to aid the reader in understanding the principles of the present subject matter. Moreover, all statements herein reciting principles, aspects, and examples of the present subject matter, as well as specific examples thereof, are intended to encompass equivalents thereof.

[0020] Fig. 1A illustrates a block diagram of an example computing system 102 for file system journaling, in accordance with an example of the present subject matter. The computing system 102 is hereinafter referred to as system 102. The system 102 may be implemented in, for example, desktop computers, multiprocessor systems, personal digital assistants (PDAs), laptops, network computers, cloud servers, minicomputers, mainframe computers, hand-held devices, such as tablets. The system 102 may also be hosting a plurality of applications. The system 102 may further be implemented in a networked environment (not shown in the figure).

[0021] The system 102 may include, for example, processor(s) 104, a journal aggregator 106 communicatively coupled to the processor(s) 104, and a dynamic journaling module 108 communicatively coupled to the processor(s) 104. [0022] The processor(s) 104 may include microprocessors, microcomputers, microcontrollers, digital signal processors, central processing units, state machines, logic circuitries, and/or any other devices that manipulate signals and data based on computer-readable instructions. Further, functions of the various elements shown in the figures, including any functional blocks labeled as "processor(s)", may be provided through the use of dedicated hardware as well as hardware capable of executing computer- readable instructions. [0023] In operation, the journal aggregator 106 may ascertain occurrence of a journal flushing event. In one example, the journal flushing event may be triggered by an operating system of the system 102. In another example, the journal flushing event may be triggered by modification of metadata corresponding to a file stored in the system 102. Upon ascertaining occurrence of the journal flushing event, the journal aggregator 106 may request the dynamic journaling module 108 to determine if aggregated journal entries stored in main memory (not shown in the figure) have to be flushed to a journal in a storage device of the system 102.

[0024] The dynamic journaling module 108 may subsequently compare a journal working set size with a dynamic journaling threshold. The dynamic journaling threshold is based on size of unused space of main memory of the system 102. The journal working set size indicates size of the aggregated journal entries stored in the main memory. In one example, the aggregated journal entries include a new journal entry created in response to the journal flushing event. For instance, in case the journal flushing event is triggered by modification of metadata corresponding to the file stored in the system 102, the new journal entry may be created to record the modifications in the main memory.

[0025] If the journal working set size is greater than the dynamic journaling threshold, then the dynamic journaling module 108 may ascertain that the aggregated journal entries have to be flushed to the journal. The dynamic journaling module 108 may subsequently flush the aggregated journal entries to the journal.

[0026] Fig. 1 B illustrates various example components of the system 102, in accordance with an example of the present subject matter. The system 102 includes the processor(s) 104, interface(s) 110, memory 112, modules 114, and data 116. The interfaces 110 may include a variety of commercially available interfaces, for example, interfaces for peripheral device(s), such as data input output devices, referred to as I/O devices, interface cards, storage devices, and network devices.

[0027] The memory 112 may be communicatively coupled to the processor(s) 104 and may include any non-transitory computer-readable medium known in the art including, for example, volatile memory, such as static random access memory (SRAM) and dynamic random access memory (DRAM), and/or non-volatile memory, such as read only memory (ROM), erasable programmable ROM, flash memories, hard disks, optical disks, and magnetic tapes. In one example, the memory 112 may include a storage device 118 and main memory 120. The storage device 118, such as hard disks and magnetic tapes may be used for storing content, such as files in the system 102. The main memory 120, such as RAM may be used for temporary storage of content for processing by the system 102.

[0028] The modules 114, amongst other things, include routines, programs, objects, components, and data structures, which perform particular tasks or implement particular abstract data types. The modules 114 may also be implemented as, signal processor(s), state machine(s), logic circuitries, and/or any other device or component that manipulate signals based on operational instructions. Further, the modules 114 can be implemented by hardware, by computer-readable instructions executed by a processing unit, or by a combination thereof.

[0029] The modules 114 may include a memory sub-system 122, the journal aggregator 106, the dynamic journaling module 108, and other module(s) 124. The other modules 124 may include programs or coded instructions that supplement applications and functions, for example, programs in an operating system of the system 102. Further, the data 116 may include file(s) 126, journal entries 128, journal 130, and other data 132. [0030] As previously described, the system 102 facilitates in minimizing memory pressure caused due to journal aggregation by maintaining the journal working set size below the dynamic journaling threshold. Minimizing the memory pressure facilitates in efficient and smooth working of the system 102. In one example, the system 102 may dynamically monitor the journal aggregation based upon the journal flushing event.

[0031] In one example, the journal aggregator 106 may ascertain the occurrence of the journal flushing event. As discussed, the journal flushing event, in one example, may be triggered by an operating system of the system 102. In said example, the operating system may trigger the journal flushing event when an application running on the system suddenly spikes memory utilization, thus creating a potential situation for memory pressure. The operating system, in such a case, may request the different applications and sub-systems, such as file system to flush cached pages from the main memory 120. For instance, the operating system may send a flush cached pages request to the journal aggregator 106. Upon receiving the flush cached pages request, the journal aggregator 106 may request the dynamic journaling module 108 to determine if the aggregated journal entries stored in the journal entries 128 have to be flushed to the journal 130.

[0032] In another example, the journal flushing event may be triggered based on a new transaction indication. The new transaction indication indicates the modification of metadata corresponding to a file, from among the files 126. The metadata of the file may be modified by an application currently running on the system 102. Upon receiving the new transaction indication, the journal aggregator 106 may analyze the new transaction indication to analyze the modifications that will be made to the metadata. The journal aggregator 106 may analyze the modifications to ascertain whether a new journal corresponding to the modifications has to be made in the main memory 120.

[0033] In case the journal aggregator 106 determines that the modifications are similar to modifications that have already been recorded, the journal aggregator 106 may ascertain that no new journal entry has to be created. The journal aggregator 106 in such a case may continue tracking modifications made to metadata of the files 126. In case the journal aggregator 106 determines that the modifications are different from the earlier recorded modifications, the journal aggregator 106 may ascertain that the new journal entry has to be created. The journal aggregator 106 in such a case requests the dynamic journaling module 108 to create the new journal entry in the main memory 120.

[0034] The dynamic journaling module 108 may initially analyze if there is sufficient memory space in the main memory 120 to create the new journal entry or whether the new journal entry will have to be flushed to the journal 130 along with the aggregated journal entries. In one example, the dynamic journaling module 108 may analyze the size of the aggregated journal entries stored in the main memory 120 and the free memory space available in the main memory 120 to determine if the new journal can be stored without increasing the memory pressure. [0035] The dynamic journaling module 108 may initially determine free, i.e., unused space of the main memory 120 of the system 102. The dynamic journaling module 108 may then compute the dynamic journaling threshold based on the size of the unused space of the main memory 120. In one example, the dynamic journaling threshold may be equal to a predetermined percentage, say, 1 % of the total unused space of the main memory 120 at the time of computing the dynamic journaling threshold. Computing the dynamic journaling threshold based on the predetermined percentage of the total unused space of the main memory 120 facilitates in ensuring that just a small fraction of the unused space is used for storing journal entries. A considerable size of the unused space of the main memory 120 is thus available for being used by the applications running on the system 102.

[0036] The dynamic journaling module 108 may further compute the journal working set size based on the size of the aggregated journal entries. In one example, the aggregated journal entries may include the journal entries stored in the journal entries 128 and the new journal entry. The dynamic journaling module 108 may subsequently compare the journal working set size with the dynamic journaling threshold to determine whether the journal working set size is greater or lesser than the dynamic journaling threshold. In case the journal working set size is greater than the dynamic journaling threshold, the dynamic journaling module 108 may flush the aggregated journal entries to the journal 130.

[0037] In case the journal working set size is less than the dynamic journaling threshold, the dynamic journaling module 108 may perform a predefined action based on the journal flushing event. For instance, if the journal flushing event is receipt of the new transaction indication, the dynamic journaling module 108 may store the new journal entry in the main memory 128. Further, in one example, the dynamic journaling module 108 may send a memory allocation request to the memory sub-system 122 in case the journal entry is not stored in existing memory space. The dynamic journaling module 108 may send the memory allocation request for allocation of main memory space in the main memory 120 for storing the new journal entry. On receiving the memory allocation request, the memory sub-system 122 may allocate the memory space to the dynamic journaling module 108. [0038] If the journal flushing event is receipt of the flush cached pages request, the dynamic journaling module 108 may continue tracking modification of the metadata of the files 126 stored in the system 102.

[0039] Further, the dynamic journaling module 108 may ascertain if the journal working set size is greater than a scalar journaling threshold to determine whether the aggregated journal entries have to be flushed to the journal. In one example, the scalar journaling threshold may be a predetermined maximum size of the aggregated journal entries. For instance, the scalar journaling threshold may be set to a predetermined size, say, 4 Megabytes (Mb). The dynamic journaling module 108 may flush the aggregated journal entries as and when the size of the aggregated journal entries becomes more than the predetermined size, say, 4 Mb.

[0040] In another example, the scalar journaling threshold may be a predetermined fraction of size of the journal saved in the storage device. For instance, the scalar journaling threshold may be set to a predetermined fraction, say, 1/16^th of the size of the journal 130. In one example, the dynamic journaling module 108 may flush the aggregated journal entries if the working set size is greater than at least one of the dynamic journaling threshold and the scalar journaling threshold.

[0041] Figs. 2, 3, and 4 illustrate example methods 200, 300, and 400, respectively, for file system journaling, in accordance with an example of the present subject matter. The order in which the methods are described is not intended to be construed as a limitation, and any number of the described method blocks may be combined in any order to implement the aforementioned methods, or an alternative method. Furthermore, the methods 200, 300, and 400 may be implemented by processing resource or computing device(s) through any suitable hardware, non-transitory machine readable instructions, or combination thereof. [0042] It may also be understood that the methods 200, 300, and 400 may be performed by programmed computing devices, such as the system 102 as depicted in Figs. 1A and 1 B. Furthermore, the methods 200, 300, and 400 may be executed based on instructions stored in a non-transitory computer readable medium, as will be readily understood. The non-transitory computer readable medium may include, for example, digital memories, magnetic storage media, such as one or more magnetic disks and magnetic tapes, hard drives, or optically readable digital data storage media.

[0043] Further, the methods 200, 300, and 400 are described below with reference to the system 102 as described above, other suitable systems for the execution of these methods can be utilized. Additionally, implementation of these methods is not limited to such examples.

[0044] Referring to Fig. 2, at block 202, a journal working set size is compared with a dynamic journaling threshold upon occurrence of a journal flushing event. In one example, the journal working set size indicates size of aggregated journal entries stored in main memory of a computing system. The aggregated journal entries include a new journal entry created in response to the journal flushing event. Further, the journaling threshold is based on size of unused space of the main memory occurrence of a journal flushing event. [0045] At block 204, a determination is made to ascertain whether the aggregated journal entries have to be flushed to a journal in a storage device of the computing system. In one example, the determination is made based at least on the comparison between the dynamic journaling threshold and the journal working set size. [0046] At block 206, the aggregated journal entries are flushed from the main memory to the journal in the storage device based on the determining. In one example, upon determining the journal working set size to be greater than the dynamic journaling threshold, the system 102 may determine to flush the aggregated journal entries.

[0047] Referring to Fig. 3, at block 302, a new transaction indication is received from an application currently running on a computing system, for example, the system 102. In one example, the new transaction indication indicates modification of metadata of a file stored in the computing system.

[0048] At block 304, it is determined whether a new journal entry corresponding to the new transaction has to be created in main memory or not. For example, in case the modifications are similar to modifications that have already been recorded, a new journal entry is not created, ('No' path from block 304), modifications of the metadata of the file are tracked at block 306.

[0049] If in case it is determined that the new journal entry has to be created ('Yes' path from block 304), it is determined whether a journal working set size is greater than a dynamic journaling threshold at block 308. For example, in case the journal working set size is greater than the dynamic journaling threshold, ('Yes' path from block 308), aggregated journal entries are flushed to a journal in a storage device of the computing system at block 310.

[0050] If in case it is determined that the journal working set size is less than the dynamic journaling threshold ('No' path from block 308), the journal entry is stored in the main memory at block 312. Further, in one example, a memory allocation request is sent to a memory sub-system for allocation of main memory space for storing the new journal entry for journal aggregation in case the journal entry is not stored in existing memory space. [0051] Referring to Fig. 4, at block 402, a flush cached pages request is received from an operating system of a computing system, for example, the system 102. In one example, the flush cached pages request is for flushing cached pages present in main memory of the computing system.

[0052] At block 404, it is determined whether a journal working set size is greater than a dynamic journaling threshold. For example, in case the journal working set size is greater than the dynamic journaling threshold, ('Yes' path from block 404), aggregated journal entries are flushed to a journal in a storage device of the computing system at block 406.

[0053] If in case it is determined that the journal working set size is less than the dynamic journaling threshold ('No' path from block 404), modifications of the metadata of file(s) stored in the computing system are continued to be tracked at block 408.

[0054] FIG. 5 illustrates a system environment 500 for file system journaling, according to an example of the present disclosure. The system environment 500 may comprise at least a portion of a public networking environment or a private networking environment, or a combination thereof. In one implementation, the system environment 500 includes a processing resource 502 communicatively coupled to a computer readable medium 504 through a communication link 506. [0055] For example, the processing resource 502 can include one or more processors of a computing device for file system journaling. The computer readable medium 504 can be, for example, an internal memory device of the computing device or an external memory device. In one implementation, the communication link 506 may be a direct communication link, such as any memory read/write interface. In another implementation, the communication link 506 may be an indirect communication link, such as a network interface. In such a case, the processing resource 502 can access the computer readable medium 504 through a network 508. The network 508 may be a single network or a combination of multiple networks and may use a variety of different communication protocols.

[0056] The processing resource 502 and the computer readable medium 504 may also be coupled to requested data sources 510 through the communication link 506, and/or to communication devices 512 over the network 508. The coupling with the requested data sources 510 enables in receiving the requested data in an offline environment, and the coupling with the communication devices 512 enables in receiving the requested data in an online environment.

[0057] In one implementation, the computer readable medium 504 includes a set of computer readable instructions, implementing a journal aggregator 514 and a dynamic journaling module 516. The set of computer readable instructions can be accessed by the processing resource 502 through the communication link 506 and subsequently executed to process requested data communicated with the requested data sources 510 in order to facilitate file system journaling. When executed by processing resource 502, the instructions of journal aggregator 514 may perform the functionalities described above in relation to journal aggregator 106. When executed by processing resource 502, the instructions of dynamic journaling module 516 may perform the functionalities described above in relation to dynamic journaling module 108.

[0058] For example, in response to a new transaction indication, indicating modification of metadata of a file stored in the communication device 512, the journal aggregator 514 may analyze the new transaction indication. The journal aggregator 514 may analyze the new transaction indication to determine if a new journal entry corresponding to modification of the metadata has to be created in main memory of the communication device 512.

[0059] The dynamic journaling module 516 may subsequently determine whether aggregated journal entries stored in the main memory have to be flushed to a journal in a storage device of the communication device 512. The dynamic journaling module 516 may perform the determination based at least on a comparison between size of unused space of the main memory and a journal working set size indicating size of the aggregated journal entries. Further, the aggregated journal entries include the new journal entry. [0060] The dynamic journaling module 516 may further flush the aggregated journal entries to the journal if the journal working set size is greater than the dynamic journaling threshold. In case the journal working set size is less than the dynamic journaling threshold, the dynamic journaling module 516 may send a memory allocation request to a memory sub-system for allocation of main memory space for storing the new journal entry for journal aggregation.

[0061] Further, the dynamic journaling module 516 may ascertain if the journal working set size is greater than a scalar journaling threshold to determine whether the aggregated journal entries have to be flushed to the journal. In one example, the scalar journaling threshold may be a predetermined maximum size of the aggregated journal entries. In another example, the scalar journaling threshold may be a predetermined fraction of size of the journal saved in the storage device.

[0062] Although examples for the present disclosure have been described in language specific to structural features and/or methods, it should stood that the appended claims are not necessarily limited to the specific features or methods described. Rather, the specific features and methods disclosed and explained as examples of the present disclosure.

Claims

I/We claim:

1. A method for file system journal ing comprising:

comparing a journal working set size with a dynamic journaling threshold upon occurrence of a journal flushing event, wherein the journal working set size indicates size of aggregated journal entries stored in main memory of a computing system, and wherein the aggregated journal entries include a new journal entry created in response to the journal flushing event, and wherein the dynamic journaling threshold is based on size of unused space of the main memory;

determining whether aggregated journal entries stored in the main memory have to be flushed to a journal in a storage device of the computing system based at least on the comparing; and

flushing the aggregated journal entries from the main memory to the journal in the storage device based on the determining.

2. The method as claimed in claim 1 , wherein the determining further comprising:

on determining the journal working set size to be greater than the dynamic journaling threshold, ascertaining that the aggregated journal entries have to be flushed to the journal.

3. The method as claimed in claim 1 , wherein the determining further comprises determining if the journal working set size is greater than a scalar journaling threshold, wherein the scalar journaling threshold is at least one of: a predetermined maximum size of the aggregated journal entries; and a predetermined fraction of size of the journal saved in the storage device.

4. The method of claim 1 , wherein the occurrence of the journal flushing event include at least one of:

receiving a new transaction indication indicating modification of metadata of a file stored in the computing system; and

receiving a flush cached pages request from an operating system of a computing system for flushing cached pages present in main memory.

5. The method of claim 4 further comprising analyzing the new transaction indication to determine if a new journal entry corresponding to the modification of metadata has to be created in the main memory.

6. The method of claim 1 further comprising sending a memory allocation request to a memory sub-system for allocation of main memory space in the main memory for storing a new journal entry for journal aggregation for the journal working set size being less than the dynamic journaling threshold, wherein the new journal entry corresponds to modification of metadata by an application being currently run on the computing system.

7. A computing system for file system journaling, the computing system comprising:

a processor;

a journal aggregator coupled to the processor to:

ascertain occurrence of a journal flushing event; and a dynamic journaling module coupled to the processor to:

compare a journal working set size with a dynamic journaling threshold, wherein the journal working set size indicates size of aggregated journal entries stored in the main memory, and wherein the aggregated journal entries include a new journal entry created in response to the journal flushing event, and wherein the dynamic journaiing threshold is based on size of unused space of main memory of the computing system;

for the journal working set size being greater than the dynamic journaiing threshold, ascertain that the aggregated journal entries have to be flushed to a journal in a storage device of the computing system; and

flush the aggregated journal entries to the journal.

8. The computing system as claimed in claim 7, wherein the dynamic journaiing module further is to determine the dynamic journaiing threshold based on the size of unused space of main memory of the computing system.

9. The computing system as claimed in claim 7, wherein the dynamic journaiing module further is to compare the journal working set size with a scalar journaiing threshold to determine if the aggregated journal entries have to be flushed to the journal, wherein the scalar journaiing threshold is at least one of:

a predetermined maximum size of the aggregated journal entries; and a predetermined fraction of size of the journal saved in the storage device.

10. The computing system as claimed in claim 7, wherein the journal flushing event is at least one of:

11. The computing system as claimed in claim 7, wherein the dynamic journaling module further is to send a memory allocation request to a memory sub-system for allocation of memory space in the main memory for storing the new journal entry for journal aggregation for the journal working set size being less than the dynamic journaling threshold.

12. A non-transitory computer readable medium having a set of computer readable instructions for file system journaling that, when executed, cause a processor to:

receive a new transaction indication from an application currently running on a computing system, the new transaction indication indicating modification of metadata of a file stored in the computing system;

analyze the new transaction indication to determine if a new journal entry corresponding to modification of the metadata has to be created in main memory;

determine whether aggregated journal entries stored in the main memory have to be flushed to a journal in a storage device of the computing system based at least on a comparison between size of unused space of the main memory and a journal working set size indicating size of the aggregated journal entries, wherein the aggregated journal entries include the new journal entry; and

flush the aggregated journal entries from the main memory to the journal in the storage device if the journal working set size is greater than the dynamic journaling threshold.

13. The non-transitory computer readable medium of claim 12, wherein the computer readable instructions, when executed, further cause the processor to:

determine a dynamic journaling threshold based on the size of unused space of main memory of the computing system;

compare the journal working set size with the dynamic journaling threshold; and

on determining the journal working set size to be greater than the dynamic journaling threshold, ascertain that the aggregated journal entries have to be flushed to the journal.

14. The non-transitory computer readable medium of claim 13, wherein the computer readable instructions, when executed, further cause the processor to send a memory allocation request to a memory sub-system for allocation of main memory space in the main memory for storing the new journal entry for journal aggregation if the journal working set size is less than the dynamic journaling threshold.

15. The non-transitory computer readable medium of claim 13, wherein the computer readable instructions, when executed, further cause the processor to ascertain if the journal working set size is greater than a scalar journaling threshold, wherein the scalar journaling threshold is at least one of: