Low Level Implementation Information
Windows NT Hosted Systems

• D³
• mvBase
• Unidata
• Universe

With hosted systems, PicLan-IP does not implement the low-level TCP/IP protocol stack itself.  Instead, PicLan-IP uses the existing Win32 TCP/IP interface, Winsock.  This is accomplished with a low-level 32-bit interface engine written in 'C' and implemented as a Windows DLL.  This interface engine is responsible for low-level network functions such as managing connection sockets, dynamically buffering network connections, queueing events, handling timed functions, etc.  All of these functions are low-level and are not specific to any high-level protocol.  High-level functions like implementing HTTP are handled in BASIC routines that call the low-level engine for data.

The low-level engine is called from BASIC through a generic "proceedure call" interface.  There are actually two variants of this interface depending on the architechure of the underlying MultiValue implementation.  D3 and mvBase are implemented where the entire Pick environment is running within a single Win32 process.  Because there is only one proces involved, the PicLan-IP support DLL can actually be loaded into the same Win32 process workspace.  This allows BASIC applications to directly cal the support DLL "in-process" and not have to copy data to transfer areas or use other RPC mechanisms.

With Unidata and Universe, each MultiValue ports is actually implemented as a seperate Win32 process.  This means that PicLan-IP cannot use a single shared DLL within a single process space.  In this case, the PicLan-IP support DLL is actually loaded by a helper or daemon process and BASIC applications call the routine through a heavily tuned RPC (Remote Proceedure Call) mechanism.  This RPC is implemented directly on top of Win32 inter-process-communication primitives and uses shared memory blocks to transfer data and Win32 events to synchronize processes.  While not quite as clean as running the support DLL in the same process space, this technique is still incredibly fast.  Whats more, the main PicLan-IP support library binary is actually shared amongst all PicLan-IP Win32 releases.

The internals of the support DLL are such that a total of 4096 TCP/IP sockets can be in use simultaniously.  Network connections are agressively and dynamically buffered allowing for multi-megabyte transfers to and from the support library without waiting for network traffic.  Because the underlying TCP/IP stacks are used for actual communications there are no real limits to the numbers of IP address or virtual hosts that can be setup concurrently.

High-level PicLan-IP functions are really no different on Win32 hosts than on any other PicLan-IP host and actually share 100% of their BASIC source code.  To be fair, the source code is conditionally compiled and massively macro expanded, but this shared environment is very important to Modular Software's ability to maintain PicLan-IP across such as broad array of MultiValue platforms.  It is in this high-level Pick/BASIC code where all of the TCP/IP services are implemented.  Win32 hosts support all of the PicLan-IP services including HTTP, SMTP, POP3, and client APIs.  Because the underlying MultiValue system already supports inbound TELNET, PicLan-IP does not implement these function on Win32.

The result is an extremely efficient, compact, and elegent set of TCP/IP services that are directly implemented within and controlled from the MultiValue environment.  The low-level communications engine allows the environment to execute with extremely good performance while still implementing all high-level protocol functions in standard BASIC for flexibility and ease of interfacing with user application code.