Compound Module FileSystem

File: filesystem.ned

File System model. Contains nine layers from application down to physical disk level.

gen: generator_type like AGenerator io_library: iolibrary_type like AIOLibrary system_call: systemcallinterface_type like ASystemCallInterface file_system: filesystem_type like AFileSystem cache: cache_type like ACache block_translator: blocktranslator_type like ABlockTranslator scheduler: diskscheduler_type like ADiskScheduler access_manager: accessmanager_type like AAccessManager physical_disk: physicaldisk_type like APhysicalDisk

Usage diagram:

The following diagram shows usage relationships between modules, networks and channels. Unresolved module (and channel) types are missing from the diagram. Click here to see the full picture.

FileSystem AAccessManager ABlockTranslator ACache APhysicalDisk AFileSystem AGenerator AIOLibrary ADiskScheduler ASystemCallInterface filesystem

Contains the following modules:

If a module type shows up more than once, that means it has been defined in more than one NED file.

AAccessManager

Abstract interface for Disk Access Managers

ABlockTranslator

Abstract interface for Block Translators

ACache

Abstract interface for Disk Cache Managers

ADiskScheduler

Abstract interface for Disk Schedulers

AFileSystem

Abstract interface for File Systems

AGenerator

Abstract interface for Disk Request Generators

AIOLibrary

Abstract interface for I/O Library

APhysicalDisk

Abstract interface for Physical Disks

ASystemCallInterface

Abstract interface for System Call Interfaces

Networks:

filesystem (no description)

Parameters:

Name Type Description
request_file string
cache_file string
scheduler_file string
generator_type string
iolibrary_type string
systemcallinterface_type string
filesystem_type string
cache_type string
blocktranslator_type string
diskscheduler_type string
accessmanager_type string
physicaldisk_type string

Unassigned submodule parameters:

Name Type Description

Source code:

module FileSystem
    parameters:
        request_file : string,
        cache_file : string,
        scheduler_file : string,

        generator_type : string,
        iolibrary_type : string,
        systemcallinterface_type : string,
        filesystem_type : string,
        cache_type : string,
        blocktranslator_type : string,
        diskscheduler_type : string,
        accessmanager_type : string,
        physicaldisk_type : string;

    submodules:

        // Disk Request Generator Options:
        //   + Generator
        //   + GenerateFromFile
        //   + XXX
        gen: generator_type like AGenerator;
            parameters:
                num_messages = input,
                ia_time = input,
                msg_length = input,
                request_file = request_file;
            display: "i=gen;p=50,50";

        // IO Library Options:
        //   + PassThroughIOLibrary
        //   + XXX
        io_library: iolibrary_type like AIOLibrary;
            display: "i=prot1;p=50,200";

        // System Call Interface Options:
        //   + PassThroughSystemCallInterface
        //   + XXX
        system_call: systemcallinterface_type like ASystemCallInterface;
            display: "i=castle;p=150,200";

        // File System Options:
        //   + PassThroughFileSystem
        //   + XXX
        file_system: filesystem_type like AFileSystem;
            display: "i=topic;p=150,125";

        // Disk Cache Managers Options:
        //   + NoCache
        //   + FIFOCache
        //   + LRUCache
        //   + PriorityLRUCache
        //   + FairShareCache
        //   + PIPriorityLRUCache  (with Priority Inheritance)
        //   + PIFairShareCache    (with Priority Inheritance)
        //   + XXX
        cache: cache_type like ACache;
            parameters:
                number_of_elements = input,
                cache_file = cache_file;
            display: "i=chest;p=150,50";

        // Block Translator Options:
        //   + XXX
        block_translator: blocktranslator_type like ABlockTranslator;
            display: "i=file_trans;p=250,100";

        // Disk Scheduler Options:
        //   + FIFOScheduler
        //   + SSTFScheduler
        //   + CScanScheduler
        //   + NStepCScanScheduler
        //   + ScanScheduler
        //   + NStepScanScheduler
        //   + PriorityScheduler
        //   + PriorityScanScheduler
        //   + PriorityCScanScheduler
        //   + PriorityNStepScanScheduler
        //   + FairShareScheduler
        //   + PreemptivePriorityNStepScanScheduler
        //   + PreemptiveFairShareScheduler
        //   + XXX
        scheduler: diskscheduler_type like ADiskScheduler;
            parameters:
                number_of_ops = input,
                period = input,
                scheduler_file = scheduler_file;
            display: "i=queue;p=350,50";

        // Access Manager Options:
        //   + SimpleAccessManager
        //   + MutexAccessManager
        access_manager: accessmanager_type like AAccessManager;
            display: "i=traffic;p=350,125";

        // Physical Disk Options:
        //   + ACPDisk
        //   + HP97560Disk
        physical_disk: physicaldisk_type like APhysicalDisk;
            parameters:
                service_time = input;
            display: "i=dsk_drv;p=350,200";

    // Describe the connections between the modules
    connections:
        // Down stream connections
        gen.out --> io_library.in;
        io_library.request --> system_call.in;
        system_call.request --> file_system.in;
        file_system.request --> cache.in;
        cache.request --> block_translator.in;
        block_translator.out --> scheduler.in;
        access_manager.get_next_request --> scheduler.get_next_request;
        scheduler.next_request --> access_manager.next_request;
        access_manager.get_block --> physical_disk.in;
        // Up stream connections
        physical_disk.out --> access_manager.block;
        access_manager.out --> scheduler.response;
        scheduler.out --> cache.response;
        cache.out --> file_system.response;
        file_system.out --> system_call.response;
        system_call.out --> io_library.response;
        io_library.out --> gen.in;
endmodule