pyxcp 0.21.9__cp311-cp311-win_amd64.whl → 0.22.23__cp311-cp311-win_amd64.whl

pyxcp/cxx/poolmgr.hpp

@@ -1,31 +0,0 @@
-#if !defined(__POOLMGR_H)
-#define __POOLMGR_H
-
-#include "pool.hpp"
-#include "periodata.hpp"
-
-/*
- *
- * PoolManager holds various resource pools.
- *
- *
- */
-
-class PoolManager {
-public:
-    using IodPool_t = Pool<PerIoData, 64>;
-
-    PoolManager() = default;
-    ~PoolManager() = default;
-
-    IodPool_t& get_iod() const {
-        return m_iod_pool;
-    }
-
-private:
-
-    static IodPool_t m_iod_pool;
-};
-
-
-#endif // __POOLMGR_H

pyxcp/cxx/test_queue.cpp

@@ -1,69 +0,0 @@
-
-#include <cstdio>
-
-#include <thread>
-
-#include <pybind11/pybind11.h>
-#include <pybind11/functional.h>
-#include <pybind11/stl.h>
-
-#include "concurrent_queue.hpp"
-
-namespace py = pybind11;
-
-auto queue = ConcurrentQueue<int> {};
-
-using tuple_t =  std::tuple<uint16_t, uint16_t, double, py::bytes>;
-
-auto frame_queue = ConcurrentQueue<tuple_t> {};
-
-void worker(int num)
-{
-    printf("Entering #%u\n", num);
-    for (int i = 0; i < 10; ++i) {
-        queue.enqueue(num + i);
-    }
-}
-
-
-int main(int ac, char const * av[])
-{
-
-    auto value = 0;
-    auto frame = std::make_tuple(20, 1, 1.0045, "hello world!!!");
-    uint16_t length, counter;
-    double timestamp;
-    py::bytes payload {};
-
-    frame_queue.enqueue(frame);
-
-    std::thread t0(worker, 10);
-    std::thread t1(worker, 20);
-    std::thread t2(worker, 30);
-    std::thread t3(worker, 40);
-    std::thread t4(worker, 50);
-
-    for (auto i = 0; i < 100; ++i) {
-        if (queue.dequeue(value, 1000)) {
-            printf("%02u\n", value);
-        } else {
-            printf("TIME-OUT!!!\n");
-            break;
-        }
-    }
-
-    t4.join();
-    t3.join();
-    t2.join();
-    t1.join();
-    t0.join();
-
-    tuple_t flonz;
-    frame_queue.dequeue(flonz);
-    //printf("%u %u %g\n", std::get<0>(flonz), std::get<1>(flonz), std::get<2>(flonz));
-
-    std::tie(length, counter, timestamp, payload) = flonz;
-    printf("%u %u %g\n", length, counter, timestamp);
-
-    return 0;
-}

pyxcp/cxx/timestamp.hpp

@@ -1,84 +0,0 @@
-#if !defined(__TIMESTAMP_HPP)
-#define __TIMESTAMP_HPP
-
-#include <cstdint>
-
-#if defined(_WIN32)
-    #include <Windows.h>
-#else
-    #include <time.h>
-#endif
-
-class Timestamp {
-public:
-
-#if defined(_WIN32)
-    Timestamp() {
-        LARGE_INTEGER tps;
-
-        ::QueryPerformanceFrequency(&tps);
-        m_ticks_per_second = tps.QuadPart;
-        m_starting_time = static_cast<double>(get_raw_value());
-    }
-
-    double get() const {
-        return get_raw_value() - m_starting_time;
-    }
-#else
-    Timestamp() {
-        struct timespec resolution = {0};
-
-        if (::clock_getres(CLOCK_MONOTONIC_RAW, &resolution) == -1) {
-        }
-        m_starting_time = get_raw_value();
-    }
-
-    double get() const {
-        struct timespec dt = {0};
-
-        dt = diff(m_starting_time, get_raw_value());
-        return static_cast<double>(dt.tv_sec) + (static_cast<double>(dt.tv_nsec) / (1000.0 * 1000.0 * 1000.0));
-    }
-#endif
-
-private:
-
-#if defined(_WIN32)
-    double get_raw_value() const {
-        LARGE_INTEGER now;
-
-        ::QueryPerformanceCounter(&now);
-
-        return static_cast<double>(now.QuadPart) / static_cast<double>(m_ticks_per_second);
-    }
-
-    double m_starting_time;
-    uint64_t m_ticks_per_second;
-#else
-    struct timespec get_raw_value() const {
-        struct timespec now;
-
-        if (::clock_gettime(CLOCK_MONOTONIC_RAW, &now) == -1) {
-        }
-        return now;
-    }
-
-    struct timespec diff(const struct timespec& start, const struct timespec& end) const {
-        struct timespec temp;
-
-        if ((end.tv_nsec-start.tv_nsec) < 0) {
-            temp.tv_sec = end.tv_sec-start.tv_sec - 1;
-            temp.tv_nsec = 1000000000L + end.tv_nsec - start.tv_nsec;
-        } else {
-            temp.tv_sec = end.tv_sec-start.tv_sec;
-            temp.tv_nsec = end.tv_nsec-start.tv_nsec;
-        }
-        return temp;
-    }
-
-    struct timespec m_starting_time;
-
-#endif
-};
-
-#endif // __TIMESTAMP_HPP

pyxcp/cxx/utils.cpp

@@ -1,38 +0,0 @@
-
-#include <cstdio>
-
-#include "utils.hpp"
-
-#if defined(_WIN32)
-    #include <Windows.h>
-#else
-
-#endif
-
-void SocketErrorExit(const char * method)
-{
-    fprintf(stderr, "%s failed with: %d\n", method, GET_LAST_SOCKET_ERROR());
-    exit(1);
-}
-
-void OsErrorExit(const char * method)
-{
-    fprintf(stderr, "%s failed with: %d\n", method, GET_LAST_ERROR());
-    exit(1);
-}
-
-#if !defined(_WIN32)
-/*
- *
- * Window-ish Sleep function for Linux.
- *
- */
-void Sleep(unsigned ms)
-{
-    struct timespec value = {0}, rem = {0};
-
-    value.tv_sec = ms / 1000;
-    value.tv_nsec = (ms % 1000) * 1000 * 1000;
-    nanosleep(&value, &rem);
-}
-#endif

pyxcp/cxx/utils.hpp

@@ -1,29 +0,0 @@
-#if !defined(__UTILS_HPP)
-#define __UTILS_HPP
-
-#if defined(_WIN32)
-    #define ZeroOut(p, s)               ::SecureZeroMemory((p), (s))
-    #define GET_LAST_SOCKET_ERROR()     WSAGetLastError()
-    #define GET_LAST_ERROR()            GetLastError()
-#else
-    #include <stdlib.h>
-    #include <errno.h>
-    #include <time.h>
-
-    #define ZeroOut(p, s)               ::memset((p), 0, (s))
-    #define CopyMemory(d, s, l)         ::memcpy((d), (s), (l))
-    #define GET_LAST_SOCKET_ERROR()     errno
-    #define GET_LAST_ERROR()            errno
-    void Sleep(unsigned ms);
-#endif
-
-#if defined(NDEBUG)
-    #define DBG_PRINT(...)
-#else
-    #define DBG_PRINT(...)              printf(VA_ARGS)
-#endif
-
-void SocketErrorExit(const char * method);
-void OsErrorExit(const char * method);
-
-#endif // __UTILS_HPP

pyxcp/cxx/win/iocp.cpp

@@ -1,242 +0,0 @@
-
-#include "iocp.hpp"
-#include "socket.hpp"
-#include "exceptions.hpp"
-#include "timeout.hpp"
-
-#include <iostream>
-#include <cstdio>
-#include <cstddef>
-
-
-/*
- *
- *
- *
- */
-
-
-static DWORD WINAPI WorkerThread(LPVOID lpParameter);
-
-IOCP::IOCP(size_t numProcessors, size_t multiplier)
-{
-    m_numWorkerThreads = numProcessors * multiplier;
-    m_port.handle  = ::CreateIoCompletionPort(INVALID_HANDLE_VALUE, nullptr, static_cast<ULONG_PTR>(0), m_numWorkerThreads);
-    if (m_port.handle == nullptr) {
-        OsErrorExit("IOCP::IOCP()");
-    }
-
-    m_threads.reserve(m_numWorkerThreads);
-
-    HANDLE hThread;
-
-    for (DWORD idx = 0; idx < m_numWorkerThreads; ++idx) {
-        hThread = ::CreateThread(nullptr, 0, WorkerThread, reinterpret_cast<LPVOID>(this), 0, nullptr);
-        ::SetThreadPriority(hThread, THREAD_PRIORITY_ABOVE_NORMAL);
-        m_threads.push_back(hThread);
-    }
-}
-
-IOCP::~IOCP()
-{
-    DWORD numThreads = static_cast<DWORD>(m_threads.size());
-    std::ldiv_t divres = std::ldiv(numThreads, MAXIMUM_WAIT_OBJECTS);
-    DWORD rounds = static_cast<DWORD>(divres.quot);
-    DWORD remaining = static_cast<DWORD>(divres.rem);
-    HANDLE * thrArray = nullptr;
-    DWORD offset = 0;
-    DWORD idx = 0;
-
-    postQuitMessage();
-
-    thrArray = new HANDLE[MAXIMUM_WAIT_OBJECTS];
-    for (DWORD r = 0; r < rounds; ++r) {
-        for (idx = 0; idx < MAXIMUM_WAIT_OBJECTS; ++idx) {
-            thrArray[idx] = m_threads.at(idx + offset);
-        }
-        ::WaitForMultipleObjects(MAXIMUM_WAIT_OBJECTS, thrArray, TRUE, INFINITE);
-        for (idx = 0; idx < MAXIMUM_WAIT_OBJECTS; ++idx) {
-            ::CloseHandle(thrArray[idx]);
-        }
-        offset += MAXIMUM_WAIT_OBJECTS;
-    }
-
-    if (remaining > 0) {
-        for (idx = 0; idx < remaining; ++idx) {
-            thrArray[idx] = m_threads.at(idx + offset);
-        }
-        ::WaitForMultipleObjects(remaining, thrArray, TRUE, INFINITE);
-        for (idx = 0; idx < remaining; ++idx) {
-            ::CloseHandle(thrArray[idx]);
-        }
-    }
-    delete[] thrArray;
-    ::CloseHandle(m_port.handle);
-}
-
-void IOCP::registerHandle(const PerHandleData& object)
-{
-    HANDLE handle;
-    bool ok;
-
-    handle = ::CreateIoCompletionPort(object.m_handle, m_port.handle, reinterpret_cast<ULONG_PTR>(&object), 0);
-    ok = (handle == m_port.handle);
-    if ((handle == nullptr) || (!ok)) {
-        OsErrorExit("IOCP::registerHandle()");
-    }
-}
-
-
-void IOCP::registerSocket(Socket& socket)
-{
-    auto handleData = PerHandleData(HandleType::HANDLE_SOCKET, socket.getHandle());
-
-    socket.setIOCP(this);
-    registerHandle(handleData);
-
-}
-
-void IOCP::postUserMessage(MessageCode messageCode, void * data) const
-{
-    if (!::PostQueuedCompletionStatus(m_port.handle, 0, static_cast<ULONG_PTR>(messageCode), (OVERLAPPED*)data)) {
-        OsErrorExit("IOCP::postUserMessage()");
-    }
-}
-
-void IOCP::postQuitMessage() const
-{
-    postUserMessage(MessageCode::QUIT, nullptr);
-}
-
-HANDLE IOCP::getHandle() const
-{
-    return m_port.handle;
-}
-
-static DWORD WINAPI WorkerThread(LPVOID lpParameter)
-{
-    IOCP const * const iocp = reinterpret_cast<IOCP const * const>(lpParameter);
-    DWORD bytesTransfered = 0;
-    ULONG_PTR completionKey;
-    PerIoData * iod = nullptr;
-    PerHandleData * phd = nullptr;
-    OVERLAPPED * olap = nullptr;
-    bool exitLoop = false;
-    MessageCode messageCode;
-    DWORD error;
-
-    printf("Entering worker thread %d.\n", ::GetCurrentThreadId());
-    while (!exitLoop) {
-        if (::GetQueuedCompletionStatus(iocp->getHandle(), &bytesTransfered, &completionKey, (LPOVERLAPPED*)&olap, INFINITE)) {
-            if (bytesTransfered == 0) {
-                messageCode = static_cast<MessageCode>(completionKey);
-                if (messageCode == MessageCode::TIMEOUT) {
-                    // TODO: Timeout handling.
-                } else if (messageCode == MessageCode::QUIT) {
-                    iocp->postQuitMessage();    // "Broadcast"
-                    exitLoop = true;
-                }
-
-            } else {
-                phd = reinterpret_cast<PerHandleData *>(completionKey);
-                iod = reinterpret_cast<PerIoData* >(olap);
-                printf("\tOPCODE: %d bytes: %d\n", iod->get_opcode(), bytesTransfered);
-                switch (iod->get_opcode()) {
-                    case IoType::IO_WRITE:
-                        iod->decr_bytes_to_xfer(bytesTransfered);
-//                        phd->m_socket->triggerRead(1024);
-                        if (iod->xfer_finished()) {
-                            delete iod;
-                        } else {
-                            //iod->m_wsabuf.buf = iod->m_wsabuf.buf + (iod->get_bytes_to_xfer() - iod->m_bytesRemaining);
-                            //iod->m_wsabuf.len = iod->m_bytesRemaining;
-                            iod->reset();
-                        }
-                        break;
-                    case IoType::IO_READ:
-                        printf("IO_READ() numBytes: %d\n", bytesTransfered);
-                        break;
-                    case IoType::IO_ACCEPT:
-                        break;
-                }
-            }
-        } else {
-            error = ::GetLastError();
-            if (olap == nullptr) {
-
-            } else {
-                // Failed I/O operation.
-                // The function stores information in the variables pointed to by lpNumberOfBytes, lpCompletionKey.
-            }
-            //Win_ErrorMsg("IOWorkerThread::GetQueuedCompletionStatus()", error);
-        }
-    }
-    printf("Exiting worker thread %d\n", ::GetCurrentThreadId());
-    ::ExitThread(0);
-}
-
-void CALLBACK Timeout_CB(void * lpParam, unsigned char TimerOrWaitFired)
-{
-    IOCP const * const iocp = reinterpret_cast<IOCP const * const>(lpParam);
-
-    //printf("TIMEOUT\n");
-    iocp->postUserMessage(MessageCode::TIMEOUT);
-}
-
-
-#if 0
-void Socket::triggerRead(unsigned int len)
-{
-    DWORD numReceived = (DWORD)0;
-    DWORD flags = (DWORD)0;
-    DWORD err = 0;
-    int addrLen;
-    static char buf[1024];
-
-    PerIoData * iod = new PerIoData(128);
-
-    iod->m_wsabuf.buf = buf;
-    iod->m_wsabuf.len = len;
-    iod->m_opcode = IoType::IO_READ;
-    iod->m_bytesRemaining = iod->m_bytesToXfer = len;
-    iod->reset();
-
-    if (m_socktype == SOCK_STREAM) {
-        if (WSARecv(m_socket,
-                    &iod->m_wsabuf,
-                    1,
-                    &numReceived,
-                    &flags,
-                    (LPWSAOVERLAPPED)&iod->m_overlapped,
-                    (LPWSAOVERLAPPED_COMPLETION_ROUTINE)nullptr)  == SOCKET_ERROR) {
-            err = WSAGetLastError();
-            if (err != WSA_IO_PENDING) {
-
-            }
-        }
-    } else if (m_socktype == SOCK_DGRAM) {
-        addrLen = sizeof(SOCKADDR_STORAGE);
-        if (WSARecvFrom(m_socket,
-                    &iod->m_wsabuf,
-                    1,
-                    &numReceived,
-                    &flags,
-                    (LPSOCKADDR)&numReceived,
-                    &addrLen,
-                    (LPWSAOVERLAPPED)&iod->m_overlapped,
-                    (LPWSAOVERLAPPED_COMPLETION_ROUTINE)nullptr)) {
-            err = WSAGetLastError();
-            if (err != WSA_IO_PENDING) {
-
-            }
-        }
-    }
-}
-
-typedef std::function<void(DWORD transferred)> CompleteHandler_t;
-
-class AsyncIoServiceFactory {
-
-};
-
-#endif

pyxcp/cxx/win/iocp.hpp

@@ -1,42 +0,0 @@
-#if !defined(__IOCP_HPP)
-#define __IOCP_HPP
-
-#include "iasyncioservice.hpp"
-#include "socket.hpp"
-#include "perhandledata.hpp"
-#include "periodata.hpp"
-#include "poolmgr.hpp"
-#include <cassert>
-#include <cstdint>
-#include <vector>
-
-#if !defined(__GNUC__)
-#pragma comment(lib,"ws2_32.lib") // MSVC only.
-#endif
-
-
-struct PerPortData {
-    HANDLE handle;
-};
-
-
-class IOCP : public IAsyncIoService {
-public:
-    IOCP(size_t numProcessors = 1, size_t multiplier = 1);
-    ~IOCP();
-    void registerSocket(Socket& socket);
-    void postUserMessage(MessageCode messageCode, void * data = nullptr) const;
-    void postQuitMessage() const;
-    HANDLE getHandle() const;
-
-protected:
-     void registerHandle(const PerHandleData& object);
-
-private:
-    PerPortData m_port;
-    DWORD m_numWorkerThreads;
-    std::vector<HANDLE> m_threads;
-    PoolManager m_pool_mgr;
-};
-
-#endif // __IOCP_HPP

pyxcp/cxx/win/perhandledata.hpp

@@ -1,24 +0,0 @@
-#if !defined(__PERHANDLEDATA_HPP)
-#define __PERHANDLEDATA_HPP
-
-#include <Windows.h>
-
-enum class HandleType {
-    HANDLE_SOCKET,
-    HANDLE_FILE,
-    HANDLE_NAMED_PIPE,
-    HANDLE_USER,
-};
-
-
-struct PerHandleData {
-    HandleType m_handleType;
-    HANDLE m_handle;
-    DWORD m_seqNoSend;
-    DWORD m_seqNoRecv;
-
-    PerHandleData(HandleType handleType, const HANDLE& handle) : m_handleType(handleType), m_handle(handle), m_seqNoSend(0), m_seqNoRecv(0) {}
-};
-
-
-#endif // __PERHANDLEDATA_HPP

pyxcp/cxx/win/periodata.hpp

@@ -1,97 +0,0 @@
-#if !defined(__PERIODATA_HPP)
-#define __PERIODATA_HPP
-
-#include <array>
-#include <cassert>
-#include "utils.hpp"
-#include <WinSock2.h>
-
-enum class IoType {
-    IO_ACCEPT,
-    IO_CONNECT,
-    IO_READ,
-    IO_WRITE
-};
-
-class PerIoData {
-
-public:
-
-    explicit PerIoData(size_t bufferSize = 128) {
-        m_xferBuffer = nullptr;
-        m_xferBuffer = new char[bufferSize];
-        m_wsabuf.buf = m_xferBuffer;
-
-        m_wsabuf.len = bufferSize;
-        m_bytesRemaining = 0;
-        m_bytes_to_xfer = 0;
-    }
-
-    ~PerIoData() {
-        if (m_xferBuffer) {
-            delete[] m_xferBuffer;
-        }
-    }
-
-    void setup_write_request() {
-
-    }
-
-    void set_opcode(IoType opcode) {
-        m_opcode = opcode;
-    }
-
-    template <typename T, size_t N> void set_buffer(std::array<T, N>& arr) {
-
-        m_wsabuf.buf = arr.data();
-        m_wsabuf.len = arr.size();
-    }
-
-    WSABUF * get_buffer() {
-        return &m_wsabuf;
-    }
-
-    IoType get_opcode() const {
-        return m_opcode;
-    }
-
-    void set_transfer_length(size_t length) {
-        m_bytesRemaining = m_bytes_to_xfer = length;
-    }
-
-    size_t get_bytes_to_xfer() const {
-        return m_bytes_to_xfer;
-    }
-
-    void decr_bytes_to_xfer(size_t amount) {
-        printf("remaining: %d amount: %d\n",m_bytesRemaining, amount);
-        assert((static_cast<int64_t>(m_bytesRemaining) - static_cast<int64_t>(amount)) >= 0);
-
-        m_bytesRemaining -= amount;
-    }
-
-    bool xfer_finished() const {
-        return m_bytesRemaining == 0;
-    }
-
-    OVERLAPPED * get_overlapped() {
-        return &m_overlapped;
-    }
-
-    void reset() {
-        ZeroOut(&m_overlapped, sizeof(OVERLAPPED));
-        m_wsabuf.len = 0;
-        m_bytesRemaining = 0;
-        m_bytes_to_xfer = 0;
-    }
-
-private:
-    OVERLAPPED m_overlapped;
-    IoType m_opcode;
-    WSABUF m_wsabuf;
-    char * m_xferBuffer;
-    size_t m_bytes_to_xfer;
-    size_t m_bytesRemaining;
-};
-
-#endif // __PERIODATA_HPP