adiosSystem.cpp

/*
 * SPDX-FileCopyrightText: 2026 Oak Ridge National Laboratory and Contributors
 *
 * SPDX-License-Identifier: Apache-2.0
 */

#include "adiosSystem.h"
#include <chrono> //system_clock, now
#include <ctime>
#include <stdexcept> // std::runtime_error, std::exception
#include <system_error>
#include <thread>

#ifndef _WIN32
#include <sys/resource.h> // getrlimits, setrlimits
#include <sys/time.h>
#endif

#include <adios2sys/Directory.hxx>
#include <adios2sys/SystemTools.hxx>

#include <unordered_set>

#include "adios2/common/ADIOSTypes.h"
#include "adios2/helper/adiosComm.h"
#include "adios2/helper/adiosLog.h"
#include "adios2/helper/adiosString.h"

// needed by IsHDF5File()
#include "adios2/core/IO.h"
#include "adios2/toolkit/transportman/TransportMan.h"
#include <cstring>

// remove ctime warning on Windows
#ifdef _WIN32
#pragma warning(disable : 4996) // ctime warning
#endif

namespace adios2
{
namespace helper
{

bool CreateDirectory(const std::string &fullPath) noexcept
{
    return static_cast<bool>(adios2sys::SystemTools::MakeDirectory(fullPath));
}

bool IsLittleEndian() noexcept
{
    uint16_t hexa = 0x1234;
    return *reinterpret_cast<uint8_t *>(&hexa) != 0x12; // NOLINT
}

std::string LocalTimeDate() noexcept
{
    struct tm now_tm;
    char buf[30];

    std::time_t now = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());

#ifdef _WIN32
    localtime_s(&now_tm, &now);
#else
    localtime_r(&now, &now_tm);
#endif
    strftime(buf, sizeof(buf), "%a %b %d %H:%M:%S %Y\n", &now_tm);

    return std::string(buf);
}

bool IsRowMajor(const std::string hostLanguage) noexcept
{
    bool isRowMajor = true;

    if (hostLanguage == "Fortran" || hostLanguage == "R" || hostLanguage == "Matlab")
    {
        isRowMajor = false;
    }

    return isRowMajor;
}

bool IsZeroIndexed(const std::string hostLanguage) noexcept
{
    bool isZeroIndexed = true;

    if (hostLanguage == "Fortran" || hostLanguage == "R")
    {
        isZeroIndexed = false;
    }
    return isZeroIndexed;
}

int ExceptionToError(const std::string &function)
{
    try
    {
        throw;
    }
    catch (std::invalid_argument &e)
    {
        helper::Log("Helper", "adiosSystem", "ExceptionToError", function + ": " + e.what(),
                    helper::FATALERROR);
        return 1;
    }
    catch (std::system_error &e)
    {
        helper::Log("Helper", "adiosSystem", "ExceptionToError", function + ": " + e.what(),
                    helper::FATALERROR);
        return 2;
    }
    catch (std::runtime_error &e)
    {
        helper::Log("Helper", "adiosSystem", "ExceptionToError", function + ": " + e.what(),
                    helper::FATALERROR);
        return 3;
    }
    catch (std::exception &e)
    {
        helper::Log("Helper", "adiosSystem", "ExceptionToError", function + ": " + e.what(),
                    helper::FATALERROR);
        return 4;
    }
}

bool IsHDF5FileLocal(const std::string &name, core::IO &io, helper::Comm &comm,
                     const std::vector<Params> &transportsParameters) noexcept
{
    bool isHDF5 = false;
    try
    {
        transportman::TransportMan tm(io, comm);
        if (transportsParameters.empty())
        {
            std::vector<Params> defaultTransportParameters(1);
            defaultTransportParameters[0]["transport"] = "File";
            tm.OpenFiles({name}, adios2::Mode::Read, defaultTransportParameters, false);
        }
        else
        {
            tm.OpenFiles({name}, adios2::Mode::Read, transportsParameters, false);
        }
        const unsigned char HDF5Header[8] = {137, 72, 68, 70, 13, 10, 26, 10};
        if (tm.GetFileSize(0) >= 8)
        {
            char header[8];
            tm.ReadFile(header, 8, 0);
            tm.CloseFiles();
            isHDF5 = !std::memcmp(header, HDF5Header, 8);
        }
    }
    catch (std::ios_base::failure &)
    {
        isHDF5 = false;
    }
    return isHDF5;
}

bool IsHDF5File(const std::string &name, core::IO &io, helper::Comm &comm,
                const std::vector<Params> &transportsParameters) noexcept
{
    size_t flag = 0;
    if (!comm.Rank())
    {
        flag = IsHDF5FileLocal(name, io, comm, transportsParameters) ? 1 : 0;
    }
    flag = comm.BroadcastValue(flag);
    return (flag == 1);
}

char BPVersionLocal(const std::string &name) noexcept
{
    const std::string mmdFileName = name + PathSeparator + "mmd.0";
    return adios2sys::SystemTools::PathExists(mmdFileName) ? '5' : '4';
}

unsigned int NumHardwareThreadsPerNode() { return std::thread::hardware_concurrency(); }

size_t RaiseLimitNoFile()
{
#ifdef _WIN32
    return _setmaxstdio(8192);
#else
    static size_t raisedLimit = 0;
    static bool firstCallRaiseLimit = true;

    if (firstCallRaiseLimit)
    {
        struct rlimit limit;
        errno = 0;
        int err = getrlimit(RLIMIT_NOFILE, &limit);
        raisedLimit = limit.rlim_cur;
        if (!err)
        {
            if (limit.rlim_cur < limit.rlim_max)
            {
                limit.rlim_cur = limit.rlim_max;
                err = setrlimit(RLIMIT_NOFILE, &limit);
                if (!err)
                {
                    getrlimit(RLIMIT_NOFILE, &limit);
                    raisedLimit = limit.rlim_cur;
                }
            }
        }

        if (err)
        {
            std::cerr << "adios2::helper::RaiseLimitNoFile(soft=" << limit.rlim_cur
                      << ", hard=" << limit.rlim_max << ") failed with error code " << errno << ": "
                      << strerror(errno) << std::endl;
        }

        firstCallRaiseLimit = false;
    }
    return raisedLimit;
#endif
}

void CleanupBPDirectory(const std::string &directory, const std::vector<std::string> &filesToKeep,
                        helper::Comm &comm)
{
    if (!comm.Rank())
    {
        // Build a set of basenames for O(1) lookup
        std::unordered_set<std::string> keepSet;
        for (const auto &fullPath : filesToKeep)
        {
            std::string basename = adios2sys::SystemTools::GetFilenameName(fullPath);
            keepSet.insert(basename);
        }

        // Scan directory and delete files not in whitelist
        adios2sys::Directory dir;
        if (dir.Load(directory).IsSuccess())
        {
            for (unsigned long i = 0; i < dir.GetNumberOfFiles(); ++i)
            {
                const std::string &fileName = dir.GetFileName(i);
                // Skip . and ..
                if (fileName == "." || fileName == "..")
                {
                    continue;
                }
                // Delete if not in whitelist
                if (keepSet.find(fileName) == keepSet.end())
                {
                    std::string filePath = dir.GetFilePath(i);
                    if (dir.FileIsDirectory(i))
                    {
                        adios2sys::SystemTools::RemoveADirectory(filePath);
                    }
                    else
                    {
                        adios2sys::SystemTools::RemoveFile(filePath);
                    }
                }
            }
        }
    }
    comm.Barrier("CleanupBPDirectory");
}

} // end namespace helper
} // end namespace adios2