IPC.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*==============================================================================
    IPC.h: Public interface for inteprocess communication module
==============================================================================*/
 
#pragma once
 
#include "CoreMinimal.h"
#include "HAL/PlatformProcess.h"
 
namespace IPC
{
    class FSynchronizedInterprocessMemory
    {
        FPlatformProcess::FSemaphore * Mutex;
 
        FPlatformMemory::FSharedMemoryRegion * Memory;
 
        FSynchronizedInterprocessMemory(FPlatformProcess::FSemaphore * InMutex, FPlatformMemory::FSharedMemoryRegion * InMemory)
            :   Mutex(InMutex)
            ,   Memory(InMemory)
        {
            check(Mutex);
            check(Memory);
        }
 
    public:
 
        ~FSynchronizedInterprocessMemory()
        {
            if (Mutex)
            {
                FPlatformProcess::DeleteInterprocessSynchObject(Mutex);
                Mutex = NULL;
            }
 
            if (Memory)
            {
                FPlatformMemory::UnmapNamedSharedMemoryRegion(Memory);
                Memory = NULL;
            }
        }
 
        static FSynchronizedInterprocessMemory * Create(const TCHAR* Name, SIZE_T Size)
        {
            FPlatformMemory::FSharedMemoryRegion * Memory = FPlatformMemory::MapNamedSharedMemoryRegion(Name, true,
                FPlatformMemory::ESharedMemoryAccess::Read | FPlatformMemory::ESharedMemoryAccess::Write, Size);
 
            if (!Memory)
            {
                return NULL;
            }
 
            // initialize memory with zeroes
            check(Memory->GetAddress());
            FMemory::Memzero(Memory->GetAddress(), Memory->GetSize());
 
            FPlatformProcess::FSemaphore * Mutex = FPlatformProcess::NewInterprocessSynchObject(Name, true);
            if (!Mutex)
            {
                FPlatformMemory::UnmapNamedSharedMemoryRegion(Memory);
                return NULL;
            }
 
            return new FSynchronizedInterprocessMemory(Mutex, Memory);
        }
 
        static FSynchronizedInterprocessMemory * OpenExisting(const TCHAR* Name, SIZE_T Size)
        {
            FPlatformMemory::FSharedMemoryRegion * Memory = FPlatformMemory::MapNamedSharedMemoryRegion(Name, false,
                FPlatformMemory::ESharedMemoryAccess::Read | FPlatformMemory::ESharedMemoryAccess::Write, Size);
 
            if (!Memory)
            {
                return NULL;
            }
 
            FPlatformProcess::FSemaphore * Mutex = FPlatformProcess::NewInterprocessSynchObject(Name, false);
            if (!Mutex)
            {
                FPlatformMemory::UnmapNamedSharedMemoryRegion(Memory);
                return NULL;
            }
 
            return new FSynchronizedInterprocessMemory(Mutex, Memory);
        }
 
        bool Write(const FString& String, uint32 MaxMillisecondsToWait = 0)
        {
            check(Mutex);
            check(Memory);
 
            // acquire
            if (!MaxMillisecondsToWait)
            {
                Mutex->Lock();
            }
            else
            {
                if (!Mutex->TryLock(MaxMillisecondsToWait * 1000000ULL))    // 1ms = 10^6 ns
                {
                    return false;
                }
            }
 
            // we have exclusive ownership now!
            TCHAR* RawMemory = reinterpret_cast< TCHAR* >(Memory->GetAddress() );
            FCString::Strncpy(RawMemory, *String, Memory->GetSize());
 
            // relinquish
            Mutex->Unlock();
 
            return true;
        }
 
        bool Read(FString& OutString, uint32 MaxMillisecondsToWait = 0)
        {
            check(Mutex);
            check(Memory);
 
            // acquire
            if (!MaxMillisecondsToWait)
            {
                Mutex->Lock();
            }
            else
            {
                if (!Mutex->TryLock(MaxMillisecondsToWait * 1000000ULL))    // 1ms = 10^6 ns
                {
                    return false;
                }
            }
 
            // we have exclusive ownership now!
            const TCHAR* RawMemory = reinterpret_cast< const TCHAR* >( Memory->GetAddress() );
            OutString = FString(RawMemory);
 
            // relinquish
            Mutex->Unlock();
 
            return true;
        }
    };
}; // namespace IPC