Defragment Class Reference

#include <Defragment.h>

Collaboration diagram for Defragment:

Public Member Functions
	Defragment (wstring Name, DefragType DefragMethod)
	~Defragment ()
void	Start (void)
void	TogglePause (void)
void	Stop (void)
bool	IsDoneYet (void)
bool	HasError (void)
wstring	GetStatusString (void)
double	GetStatusPercent (void)
DefragType	GetDefragType (void)
DefragReport &	GetDefragReport (void)
DriveVolume &	GetVolume (void)
void	Lock (void)
void	Unlock (void)
bool	GetDoLimitLength (void)
void	SetDoLimitLength (bool L)

Private Member Functions
void	FastDefrag (void)
void	ExtensiveDefrag (void)
void	SetStatusString (wstring NewStatus)

Private Attributes
DWORD	LastBMPUpdate
DefragReport	Report
bool	DoLimitLength
DefragType	Method
wstring	DriveName
DriveVolume	Volume
wstring	StatusString
wstring	ErrorString
double	StatusPercent
Mutex	DefragMutex
bool	Error
bool	Done
bool	PleaseStop
bool	PleasePause
DefragType	DefragMethod

Detailed Description

Definition at line 41 of file Defragment.h.

Constructor & Destructor Documentation

Defragment()

Defragment::Defragment	(	wstring	Name,
		DefragType	DefragMethod
	)

Definition at line 81 of file Defragment.cpp.

{
    Method = DefragMethod;
    DoLimitLength = true;
    Error = false;
    Done = false;
    PleaseStop = false;
    PleasePause = false;
    DriveName = Name;
    StatusPercent = 0.0f;
    LastBMPUpdate = GetTickCount ();
 
    SetStatusString (L"Opening volume " + Name);
    if (!Volume.Open (Name))
    {
        SetStatusString (L"Error opening volume " + Name);
        Error = true;
        Done = true;
        StatusPercent = 100.0f;
    }
 
    return;
}

~Defragment()

Defragment::~Defragment

(

)

Definition at line 106 of file Defragment.cpp.

{
    if (!IsDoneYet ())
    {
        Stop ();
        while (!IsDoneYet()  &&  !HasError())
        {
            SetStatusString (L"Waiting for thread to stop ...");
            Sleep (150);
        }
    }
 
    Volume.Close ();
    return;
}

Member Function Documentation

ExtensiveDefrag()

void Defragment::ExtensiveDefrag ( void  )

private

FastDefrag()

void Defragment::FastDefrag ( void  )

private

GetDefragReport()

DefragReport & Defragment::GetDefragReport ( void  )

inline

Definition at line 58 of file Defragment.h.

{ return (Report); }

Referenced by ReportDialogProc().

GetDefragType()

DefragType Defragment::GetDefragType ( void  )

inline

Definition at line 57 of file Defragment.h.

{ return (Method); }

Referenced by MainDialogProc().

GetDoLimitLength()

bool Defragment::GetDoLimitLength ( void  )

inline

Definition at line 66 of file Defragment.h.

{ return (DoLimitLength); }

GetStatusPercent()

double Defragment::GetStatusPercent

(

void

)

Definition at line 145 of file Defragment.cpp.

{
    return (StatusPercent);
}

Referenced by GetDefragTitle(), and UpdateDefragInfo().

GetStatusString()

wstring Defragment::GetStatusString

(

void

)

Definition at line 133 of file Defragment.cpp.

{
    wstring ReturnVal;
 
    Lock ();
    ReturnVal = StatusString;
    Unlock ();
 
    return (ReturnVal);
}

Referenced by Start(), and UpdateDefragInfo().

GetVolume()

DriveVolume & Defragment::GetVolume ( void  )

inline

Definition at line 59 of file Defragment.h.

{ return (Volume); }

Referenced by GetDefragTitle(), and SetReportInfo().

HasError()

bool Defragment::HasError

(

void

)

Definition at line 454 of file Defragment.cpp.

{
    return (Error);
}

Referenced by MainDialogProc(), SetDisables(), and ~Defragment().

IsDoneYet()

bool Defragment::IsDoneYet

(

void

)

Definition at line 151 of file Defragment.cpp.

{
    return (Done);
}

Referenced by MainDialogProc(), SetDisables(), and ~Defragment().

Lock()

void Defragment::Lock ( void  )

inline

Definition at line 62 of file Defragment.h.

{ DefragMutex.Lock ();   }

Referenced by GetStatusString(), SetStatusString(), Stop(), and TogglePause().

SetDoLimitLength()

void Defragment::SetDoLimitLength ( bool  L )

inline

Definition at line 67 of file Defragment.h.

{ DoLimitLength = L; }

Referenced by MainDialogProc().

SetStatusString()

void Defragment::SetStatusString ( wstring  NewStatus )

private

Definition at line 123 of file Defragment.cpp.

{
    Lock ();
    StatusString = NewStatus;
    Unlock ();
 
    return;
}

Referenced by Defragment(), Start(), Stop(), TogglePause(), and ~Defragment().

Start()

void Defragment::Start

(

void

)

Definition at line 157 of file Defragment.cpp.

{
    uint32 i;
    uint64 FirstFreeLCN;
    uint64 TotalClusters;
    uint64 ClustersProgress;
    wchar_t PrintName[80];
    int Width = 70;
 
    if (Error)
        goto DoneDefrag;
 
    // First thing: build a file list.
    SetStatusString (L"Getting volume bitmap");
    if (!Volume.GetBitmap())
    {
        SetStatusString (L"Could not get volume " + DriveName + L" bitmap");
        Error = true;
        goto DoneDefrag;
    }
 
    LastBMPUpdate = GetTickCount ();
 
    if (PleaseStop)
        goto DoneDefrag;
 
    SetStatusString (L"Obtaining volume geometry");
    if (!Volume.ObtainInfo ())
    {
        SetStatusString (L"Could not obtain volume " + DriveName + L" geometry");
        Error = true;
        goto DoneDefrag;
    }
 
    if (PleaseStop)
        goto DoneDefrag;
 
    SetStatusString (L"Building file database for volume " + DriveName);
    if (!Volume.BuildFileList (PleaseStop, StatusPercent))
    {
        SetStatusString (L"Could not build file database for volume " + DriveName);
        Error = true;
        goto DoneDefrag;
    }
 
    if (PleaseStop)
        goto DoneDefrag;
 
    SetStatusString (L"Analyzing database for " + DriveName);
    TotalClusters = 0;
    for (i = 0; i < Volume.GetDBFileCount(); i++)
    {
        TotalClusters += Volume.GetDBFile(i).Clusters;
    }
 
    // Defragment!
    ClustersProgress = 0;
 
    // Find first free LCN for speedier searches ...
    Volume.FindFreeRange (0, 1, FirstFreeLCN);
 
    if (PleaseStop)
        goto DoneDefrag;
 
    // Analyze?
    if (Method == DefragAnalyze)
    {
        uint32 j;
 
        Report.RootPath = Volume.GetRootPath ();
 
        Report.FraggedFiles.clear ();
        Report.UnfraggedFiles.clear ();
        Report.UnmovableFiles.clear ();
 
        Report.FilesCount = Volume.GetDBFileCount () - Volume.GetDBDirCount ();
        Report.DirsCount = Volume.GetDBDirCount ();
        Report.DiskSizeBytes = Volume.GetVolumeInfo().TotalBytes;
 
        Report.FilesSizeClusters = 0;
        Report.FilesSlackBytes = 0;
        Report.FilesSizeBytes = 0;
        Report.FilesFragments = 0;
 
        for (j = 0; j < Volume.GetDBFileCount(); j++)
        {
            FileInfo Info;
 
            Info = Volume.GetDBFile (j);
 
            Report.FilesFragments += max ((size_t)1, Info.Fragments.size()); // add 1 fragment even for 0 bytes/0 cluster files
 
            if (Info.Attributes.Process == 0)
                continue;
 
            SetStatusString (Volume.GetDBDir (Info.DirIndice) + Info.Name);
 
            Report.FilesSizeClusters += Info.Clusters;
            Report.FilesSizeBytes += Info.Size;
 
            if (Info.Attributes.Unmovable == 1)
                Report.UnmovableFiles.push_back (j);
 
            if (Info.Fragments.size() > 1)
                Report.FraggedFiles.push_back (j);
            else
                Report.UnfraggedFiles.push_back (j);
 
            StatusPercent = ((double)j / (double)Report.FilesCount) * 100.0f;
        }
 
        Report.FilesSizeOnDisk = Report.FilesSizeClusters * (uint64)Volume.GetVolumeInfo().ClusterSize;
        Report.FilesSlackBytes = Report.FilesSizeOnDisk - Report.FilesSizeBytes;
        Report.AverageFragments = (double)Report.FilesFragments / (double)Report.FilesCount;
        Report.PercentFragged = 100.0f * ((double)(signed)Report.FraggedFiles.size() / (double)(signed)Report.FilesCount);
 
        uint64 Percent;
        Percent = (10000 * Report.FilesSlackBytes) / Report.FilesSizeOnDisk;
        Report.PercentSlack = (double)(signed)Percent / 100.0f;
    }
    else
    // Go through all the files and ... defragment them!
    for (i = 0; i < Volume.GetDBFileCount(); i++)
    {
        FileInfo Info;
        bool Result;
        uint64 TargetLCN;
        uint64 PreviousClusters;
 
        // What? They want us to pause? Oh ok.
        if (PleasePause)
        {
            SetStatusString (L"Paused");
            PleasePause = false;
 
            while (PleasePause == false)
            {
                Sleep (50);
            }
 
            PleasePause = false;
        }
 
        if (PleaseStop)
        {
            SetStatusString (L"Stopping");
            break;
        }
 
        //
        Info = Volume.GetDBFile (i);
 
        PreviousClusters = ClustersProgress;
        ClustersProgress += Info.Clusters;
 
        if (Info.Attributes.Process == 0)
            continue;
 
        if (!DoLimitLength)
            SetStatusString (Volume.GetDBDir (Info.DirIndice) + Info.Name);
        else
        {
            FitName (PrintName, Volume.GetDBDir (Info.DirIndice).c_str(), Info.Name.c_str(), Width);
            SetStatusString (PrintName);
        }
 
        // Calculate percentage complete
        StatusPercent = 100.0f * double((double)PreviousClusters / (double)TotalClusters);
 
        // Can't defrag directories yet
        if (Info.Attributes.Directory == 1)
            continue;
 
        // Can't defrag 0 byte files :)
        if (Info.Fragments.empty())
            continue;
 
        // If doing fast defrag, skip non-fragmented files
        // Note: This assumes that the extents stored in Info.Fragments
        //       are consolidated. I.e. we assume it is NOT the case that
        //       two extents account for a sequential range of (non-
        //       fragmented) clusters.
        if (Info.Fragments.size() == 1  &&  Method == DefragFast)
            continue;
 
        // Otherwise, defrag0rize it!
        int Retry = 3;  // retry a few times
        while (Retry > 0)
        {
            // Find a place that can fit the file
            Result = Volume.FindFreeRange (FirstFreeLCN, Info.Clusters, TargetLCN);
 
            // If yes, try moving it
            if (Result)
            {
                // If we're doing an extensive defrag and the file is already defragmented
                // and if its new location would be after its current location, don't
                // move it.
                if (Method == DefragExtensive  &&  Info.Fragments.size() == 1  &&
                    TargetLCN > Info.Fragments[0].StartLCN)
                {
                    Retry = 1;
                }
                else
                {
                    if (Volume.MoveFileDumb (i, TargetLCN))
                    {
                        Retry = 1; // yay, all done with this file.
                        Volume.FindFreeRange (0, 1, FirstFreeLCN);
                    }
                }
            }
 
            // New: Only update bitmap if it's older than 15 seconds
            if ((GetTickCount() - LastBMPUpdate) < 15000)
                Retry = 1;
            else
            if (!Result  ||  Retry != 1)
            {   // hmm. Wait for a moment, then update the drive bitmap
                //SetStatusString (L"(Reobtaining volume " + DriveName + L" bitmap)");
 
                if (!DoLimitLength)
                {
                    SetStatusString (GetStatusString() + wstring (L" ."));
                }
 
                if (Volume.GetBitmap ())
                {
                    LastBMPUpdate = GetTickCount ();
 
                    if (!DoLimitLength)
                        SetStatusString (Volume.GetDBDir (Info.DirIndice) + Info.Name);
                    else
                        SetStatusString (PrintName);
 
                    Volume.FindFreeRange (0, 1, FirstFreeLCN);
                }
                else
                {
                    SetStatusString (L"Could not re-obtain volume " + DriveName + L" bitmap");
                    Error = true;
                }
            }
 
            Retry--;
        }
 
        if (Error == true)
            break;
    }
 
DoneDefrag:
    wstring OldStatus;
 
    OldStatus = GetStatusString ();
    StatusPercent = 99.999999f;
    SetStatusString (L"Closing volume " + DriveName);
    Volume.Close ();
    StatusPercent = 100.0f;
 
    // If there was an error then the wstring has already been set
    if (Error)
        SetStatusString (OldStatus);
    else
    if (PleaseStop)
        SetStatusString (L"Volume " + DriveName + L" defragmentation was stopped");
    else
        SetStatusString (L"Finished defragmenting " + DriveName);
 
    Done = true;
 
    return;
}

Referenced by DefragThread().

Stop()

void Defragment::Stop

(

void

)

Definition at line 443 of file Defragment.cpp.

{
    Lock ();
    SetStatusString (L"Stopping ...");
    PleaseStop = true;
    Unlock ();
 
    return;
}

Referenced by MainDialogProc(), and ~Defragment().

TogglePause()

void Defragment::TogglePause

(

void

)

Definition at line 432 of file Defragment.cpp.

{
    Lock ();
    SetStatusString (L"Pausing ...");
    PleasePause = true;
    Unlock ();
 
    return;
}

Unlock()

void Defragment::Unlock ( void  )

inline

Definition at line 63 of file Defragment.h.

{ DefragMutex.Unlock (); }

Referenced by GetStatusString(), SetStatusString(), Stop(), and TogglePause().

Member Data Documentation

DefragMethod

DefragType Defragment::DefragMethod

private

Definition at line 88 of file Defragment.h.

Referenced by Defragment().

DefragMutex

Mutex Defragment::DefragMutex

private

Definition at line 83 of file Defragment.h.

Referenced by Lock(), and Unlock().

DoLimitLength

bool Defragment::DoLimitLength

private

Definition at line 76 of file Defragment.h.

Referenced by Defragment(), GetDoLimitLength(), SetDoLimitLength(), and Start().

Done

bool Defragment::Done

private

Definition at line 85 of file Defragment.h.

Referenced by Defragment(), IsDoneYet(), and Start().

DriveName

wstring Defragment::DriveName

private

Definition at line 78 of file Defragment.h.

Referenced by Defragment(), and Start().

Error

bool Defragment::Error

private

Definition at line 84 of file Defragment.h.

Referenced by Defragment(), HasError(), and Start().

ErrorString

wstring Defragment::ErrorString

private

Definition at line 81 of file Defragment.h.

LastBMPUpdate

DWORD Defragment::LastBMPUpdate

private

Definition at line 74 of file Defragment.h.

Referenced by Defragment(), and Start().

Method

DefragType Defragment::Method

private

Definition at line 77 of file Defragment.h.

Referenced by Defragment(), GetDefragType(), and Start().

PleasePause

bool Defragment::PleasePause

private

Definition at line 87 of file Defragment.h.

Referenced by Defragment(), Start(), and TogglePause().

PleaseStop

bool Defragment::PleaseStop

private

Definition at line 86 of file Defragment.h.

Referenced by Defragment(), Start(), and Stop().

Report

DefragReport Defragment::Report

private

Definition at line 75 of file Defragment.h.

Referenced by GetDefragReport(), and Start().

StatusPercent

double Defragment::StatusPercent

private

Definition at line 82 of file Defragment.h.

Referenced by Defragment(), GetStatusPercent(), and Start().

StatusString

wstring Defragment::StatusString

private

Definition at line 80 of file Defragment.h.

Referenced by GetStatusString(), and SetStatusString().

Volume

DriveVolume Defragment::Volume

private

Definition at line 79 of file Defragment.h.

Referenced by Defragment(), GetVolume(), Start(), and ~Defragment().

---

The documentation for this class was generated from the following files:

• modules/rosapps/applications/fraginator/Defragment.h
• modules/rosapps/applications/fraginator/Defragment.cpp