Modules/Authors

Files

Author: Amine Moulay Ramdane


Click here to download the zip file: Zip


Description: Parallel archiver using my Parallel LZO , Parallel LZ4 , Parallel Zlib ,  Parallel Bzip and Parallel LZMA compression algorithms..

Supported features:

- Opens and creates archives using my Parallel LZ4 or Parallel LZO or Parallel Zlib or Parallel Bzip or Parallel LZMA compression algorithms.

- Wide range of compression Parallel algorithms: Parallel LZ4, Parallel LZO, Parallel ZLib, Parallel BZip and   Parallel LZMA with different compression levels

- Compiles into exe - no dll/ocx required.

- 64 bit supports - lets you create archive files over 4 GB , 
  supports archives up  to 2^63 bytes, compresses and 
  decompresses files up to 2^63 bytes.

- Now my Parallel Zlib gives 5% better performance than Pigz.

- Supports memory and file streams , adds compressed data 
  directly from streams and extracts archived files to streams 
  without creating temp files.

- Supports in-memory archives

- You can use it as a hashtable from the hardisk or from the memory

- Fault tolerant to power failures etc..

- Creates encrypted archives using Parallel AES encryption with 256 bit keys.

- Fastest compression levels are extremely fast

- Good balanced compression levels provide  both good compression ratio and high speed

- Maximum compression levels provide much better compression ratio than Zip, RAR and BZIP and the same as  7Zip with 8 megabytes dictionary.

- It supports both compression and decompression rate indicator

- You can test the integrity of your archive

- Easy object programming interface

- Full source codes available.

- Platform: Win32 , Win64

Please look at test_pzlib.pas , test_plzo.pas , test_plz4.pas ,  test_pbzip.pas and test_plzma.pas demos inside the zip file, compile and execute them.. -

When you want to delete files inside the archive you have to call the DeleteFiles() method , the DeleteFiles() method will not delete the files, it will mark the files as deleted , when you want to delete completly the files , you have to call the DeletedItems() method to see how many files are marked deleted and after that you use the Clean() method to delete completly the files from the archive. I have implemented it like that, cause it's better in my opinion..

And my parallel archiver uses a hashtable to store the file names and there corresponding file positions so that you can direct access to files inside the archive when decompressing, and deleting etc. so it's very fast.

Please look at the test_pzlib.pas, test_plzo.pas, test_plz4.pas , test_pbzip.pas and test_plzma.pas demos inside the zip file to see how to use my Parallel archiver.

And please don't use directly the ParalleZlib.pas that i have included inside the Parallel archiver zip file, cause i have modified it to work correclty with my Parallel archiver.

If you want to use my ParallelZlib library just download it from my website, or download my other Parallel compression library.

You can now use my Parallel archiver as a hashtable from the hardisk with 0(1) access, you can for example
stream your database row with my ParallelVarFiler into a memory stream or into a string, and store it with my Parallel archiver into an  archive, and after that your can access your rows into the hardisk as a hashtable with O(1) access, you can use it like that as a database if you  have for example id keys that you want to map to database rows, that will be a good idea to
use my Parallel archiver as a hashtable.

Question:

What's your newest ideas behind your parallel archiver ?

Answer:

Of course my Parallel Archiver supports Parallel compression etc. but my newest ideas behind my Parallel Archiver are the following:

I have played with Winzip and 7Zip , but if you want to give some files to extract or to test there integrity, they both (Winzip and 7Zip) will use sequential access and that's bad i think, so i have decided to implement a O(1) access that is very fast for extraction and and for testing the integrity etc. into my Parallel Archiver and for that i have used an in-memory hashtable that maintains the files names and there correponding file positions , and my second idea is that my Parallel Archiver is fault tolerant to power failures and also if your hardisk is full and you get file corruption etc. so my Parallel Archiver is fault tolerant to this kind of problems , 7Zip and Winzip i think are not fault tolerant to those kind of problems. 

I have just played with 7Zip , and i have compressed 3 files into the archive and after than i have opened the archive with an editor and i have deleted some bytes and i have saved the file and after that when i have tried to open the archive, 7zip responded that the file is corrupted, so 7Zip is not fault tolerant, i think that with WinZip it's the same, but i have done the same test with  my Parallel archiver, and it's recovering from the file damage, so it's fault tolerant to this kind of damages, such as power failures and when also the disk is full and you get a file corruption etc. I have implemented this kind of  fault tolerancy into my Parallel archiver.

I have updated my Parallel archiver and i have added the Update() method, it's overloaded now in the first version you pass a key name and a TStream, and in the second version you pass a key name and a filename. Please look at the test_pzlib.pas demo inside the zip file to see how to use those methods.

So now you have all the methods to use my Parallel archiver as a Hashtable from the hardisk with direct access to the compressed and/or encrypted data with O(1) complexity and very fast acces to the data , the DeleteFiles() has a O(1) complexity the ExtractFiles() and Extract() have also O(1) complexity and  GetInfo() is also O(1) and of course the AddFiles() is also O(1), the Test() method is also O(1). So now it's extremely fast.

Parallel archiver supports the storing and restoring of the following file attributes:

Hidden, Archive, System, and Read only attributes.

To store and restore them just set the AddAttributes property like this:

pzr.AddAttributes:=[ffArchive,ffReadOnly,ffHidden,ffSystem];

Hope you will enjoy my Parallel archiver.

Here is the public methods that i have implemented:

Constructor Create(file1:string,size:integer;nbrprocs:integer);
- Creates a new TPZArchiver ready to use, size is the hashtable size for the index(Key file names and the corresponding file position ,and file1 is the file archive, nbrprocs is the number of cores you have specify to run Zlib , LZ4, LZO , Bzip and LZMA  in parallel.

Destructor Destroy;
- Destroys the TPZArchiver object and cleans up.

function AddFiles;
- Add the files to the archive.

function AddStream;
-Add the stream to the archive.

function DeleteFiles;
- Delete the TStringList content from the archive.

function Erase;
   - Erase the data inside the archive and inside  the hashtable.

function Update;
- Update the file or the stream inside the archive

function ExtractFiles;
- Extract the TStringList content from the archive.

function ExtractAll;
- Extract all the files from the archive.

function Extract;
-Extract the file to the stream.

function Test;
- Test the integrity of the files inside the archive.

function GetInfo;
- Get the file info that is returned in a TZSearchRec record.

function ClearFile;
- Deletes all contents of the archive.

function Clean:boolean
- Clean the marked deleted items from the file.

function DeletedItems:integer
- Return the number of items marked deleted.

function LoadIndex:boolean
- Load the the file names keys and there correponding file positions values from the file passed to the constructor into the hashtable.

function Exists(Name : String) : Boolean;
- Returns True if a file Name exists

procedure GetKeys(Strings : Tstrings);
- Fills up a TStrings descendant with all the file names.

function Count : Integer;
- Returns the number of files inside the archive.


PUBLIC PROPERTIES:

Indicator : boolean
- To show the compression and decompression indicator.
CompressionLevel;
- Set and read the compression level.
Overwrite:boolean
- To update and overwrite the file without asking .
Freshen: boolean
-Add newer files to the archiver and extract newer files from the archive.
AddRecurse: boolean
- AddFiles() method will recurse on subdirectories. 
Stream:boolean
  - The archive is exposed as a TStream, use it for in-memory archive or disk archive.
AddAttributes: TAttrOptions
- FindFile attributes for the AddFiles() method, look inside FindFile component.

Language: FPC Pascal v2.2.0+ / Delphi 7+: http://www.freepascal.org/

Operating Systems: Win32 and Win64 (will be ported soon to Linux and Mac (x86)).

And inside defines.inc you can use the following defines:

{$DEFINE CPU32} and {$DEFINE Win32} for 32 bits systems

{$DEFINE CPU64} and {$DEFINE Win64} for 64 bits systems

Required FPC switches: -O3 -Sd -dFPC -dWin32 -dFreePascal

-Sd for delphi mode....

Required Delphi switches: -DMSWINDOWS -$H+ -DDelphi

Author: Amine Moulay Ramdane


Click here to download the zip file: Zip


Description:

Parallel Compression Library implements Parallel Gzip , Parallel Bzip , Parallel LZMA and Parallel LZ and Parallel LZO algorithms using my Thread Pool Engine.

- Now my ParallelGzip gives 5% better performance than Pigz.

- It supports memory streams, file streams and files

- 64 bit supports - lets you create archive files over 4 GB , 
  supports archives up  to 2^63 bytes, compresses and 
  decompresses files up to 2^63 bytes.

- Parallel compression and parallel decompression are extremely fast

- It supports both compression and decommpression rate indicator

- You can test the integrity of your compressed file

- Easy programming interface

- Full source codes available.


Just look at the Easy compression library for example,
if you have noticed it's not a parallel compression library.

http://www.componentace.com/ecl_features.htm

And look at its pricing:

http://www.componentace.com/order/order_product.php?id=4


My parallel compression library costs you 0$
and it's a parallel compression library..

Please see the benchmarks here: benchmarks.

Please look at test_pgzip.pas , test_pbzip.pas , test_plzma.pas , test_plz.pas and test_plzo.pas demos inside the zip file, compile and execute them... -

Language: FPC Pascal v2.2.0+ / Delphi 7+: http://www.freepascal.org/

Note: Parallel Gzip , Parallel Bzip, Paralle LZ and Parallel LZO work with both FreePascal and Delphi , but Parallel LZMA works only with Delphi 7 and up.

Operating Systems: Win , Linux and Mac (x86).

Note: to be able to port to Linux and Mac OSX you have to compile the dynamic libraries...

Required FPC switches: -O3 -Sd -dFPC -dWin32 -dFreePascal

-Sd for delphi mode....

-dUnix for Linux,MacOSX etc.

Required Delphi switches: -DMSWINDOWS -$H+ -DDelphi

Description:

Collect different types of variables and save them into one file or stream. TParallelVarFiler reads and writes on files, streams and Strings. You can collect Strings, Integers and Dates, in fact everything that can be stored in a variant. In addition you can collect Streams.

You can use also ParallelVarFiler to send parameters over network. It can be used for example to share data by any IPC mechanism.

And please look at test.pas and test1.pas a parallel variable filer examples - compile and execute them...

Now you can use ParallelVarFiler as a small to medium database, i have added a Clean() and DeletedItems() methods and i have changed the constructor, now you can pass a file name to the constructor where the data will be wrote and updated and deleted... if you pass and empty file name the data will be updated and wrote and deleted only in memory. When you use a file name in the constructor, many readers and one writer can proceed concurrently. But when you pass an empty file name to the constructor, many writers and many readers can proceed concurrently in memory. and when you read a data item it only use the parallel hashtable in memory, hardisk is not used.

I want to add another thing, when you pass a file name to the constructor and delete or update the items, those items will be marked deleted from the file, and you can use DeletedItems() to see how many data items are marked deleted in the file, and use after that the Clean() method to delete completly those data items from the file.

How can you store mutiple data inside a database row and map it to a key ?

You can simply use Parallel Variable Filer for that and stream your mutiple data variants and map them to a key...

As you know ParallelVarFiler is using ParallelHashList (a parallel hashtable that scales on multicores), so when you are using the GetKeys() method , and you want to get the data of those keys don't forget to test if the variant is not empty by using the VarIsEmpty() function, and when you are using GetStream() you can test if the data exists by testing the return boolean value from GetStream().

ParallelVarFiler is easy to learn, i have documented all the methods , and please read inside ParallelVarFiler.pas about
them.

Now ParallelVarFiler is Fault tolerant to power failures etc. i have done a simulation of power failures and data file damages and ParallelVarFiller is recovering from power failure and damages of the data file ... And when there is a power failure or the program has crached and you want to recover from a damage to your data file you have only to call the LoadData() method.

As you know ParallelVarFiler is using ParallelHashList (a parallel hashtable), but as you know ParallelHashList is cache unfriendly since it's using a hash mechanism etc. and as you know ParallelVarFiler and ParallelHashlist  are memory bound, so since ParallelHashList is cache unfriendly and  it's memory bound so i don't think ParallelVarFiler or ParallelHahsList will scale very well, to avoid this problem you have to use something like replication across computers using TCP/IP and using your database in each computer and load balance between computers, but even if you are using replication and load balancing this can make the memory and hardisk truly parallel but this will not avoid the problem with the network bandwidth limitation. But ParallelVarFiler and ParallelHashlist are scaling to a certain point and they are fast and they are still usefull.

Please see the test.pas example inside the zip file to see how i am using it...

But please read the following:

This software is provided on an "as-is" basis, with no warranties, express or implied. The entire risk and liability of using it is yours. Any damages resulting from the use or misuse of this software will be the responsibility of the user.

please look at the test.pas and test1.pas example inside the zip file to see how to use ParallelVarFiler...

Here is the methods that have been implemented:

PUBLIC METHODS:

constructor Create(file1:string,size,mrews:integer;casesensitive:boolean);

- Creates a new VarFiler ready to use, with size and with mrews number of mrewa and casesensitive

for case sensitive keys,the number of MREWS(multiple-readers-exclusive-writer) must be less or

equal to the Hashtable size and file1 is the the file to write to, if file1 is an empty string

the data will be wrote only to memory and use SaveToFile() to write to a file.

destructor Destroy;

- Destroys the ParallelVarFiler object and cleans up.

procedure Clear;

- Deletes all contents.

function Clean:boolean

- Clean the deleted items from the file.

function DeletedItems:integer

- Return the number of items marked deleted.

function LoadData:boolean

- Load the data from the file passed to the constructor.

function Delete(Name : String):boolean;

- Deletes the variable with Name.

function Exists(Name : String) : Boolean;

- Returns True if a variable with Name exists

procedure GetKeys(Strings : TstringList);

- Fills up a TStringList descendant with all the keys.

function Count : Integer;

- Returns the number of variables

function Add(Name : String; Value : Variant ):boolean;

- Adds a new variable , given the Name

function AddStream( Name : String;Stream : TStream ):boolean;

- Adds a new Stream, given the Name

function Update(Name : String; Value : Variant):boolean;

- Update the new variable , given the Name

function UpdateStream(Name : String; Stream : TStream ):boolean;

- Updated a new Stream , given the Name

function GetStream(Name : String;Stream : TStream):boolean;

- Fills up the stream with data

procedure SaveToStream(Stream : TStream);

- Saves all variables, streams and Graphics to a stream.

procedure SaveToFile(FileName : String);

- Saves all variables, streams and Graphics to a file.

procedure SaveToString(out S : String);

- Saves all variables, streams and Graphics to a string.

function LoadFromStream(Stream : TStream):boolean;

- Loads all variables, streams and Graphics from a stream.

function LoadFromFile(FileName : String):boolean;

- Loads all variables, streams and Graphics from a File.

function LoadFromString(S : String):boolean;

- Loads all variables, streams and Graphics from a string.

function Stream2String(Stream1: TStream;var Mystring:string): boolean;

procedure String2Stream(var String2BeSaved:string; Stream1: TStream);

procedure Variant2Stream(var VR:variant; Stream1: TStream);

function Stream2Variant(Stream1: TStream;var VR:variant): boolean;

PUBLIC PROPERTIES:

Items : Variant

- Get the value (indexed).

Language: FPC Pascal v2.2.0+ / Delphi 7+: http://www.freepascal.org/

Operating Systems: Win , Linux and Mac (x86).

Required FPC switches: -O3 -Sd -dFPC -dWin32 -dFreePascal

-Sd for delphi mode....

Required Delphi switches: -DMSWINDOWS -$H+

For Delphi use -DDelphi

Authors:

MREW lock(multiple-readers-exclusive-writer lock) that works across processes and threads.

Language: FPC Pascal v2.2.0+ / Delphi 7+: http://www.freepascal.org/

Operating Systems: Win , Linux and Mac (x86).

Required FPC switches: -O3 -Sd -dFPC -dWin32 -dFreePascal

-Sd for delphi mode....

Required Delphi switches: -DMSWINDOWS -$H+

For Delphi use -DDelphi

Author: Amine Moulay Ramdane


Click here to download the zip file: Zip (for Delphi)

Click here to download the zip file: Zip (for Lazarus and freepascal)

Description:

Parallel Sort Library that supports Parallel Quicksort, Parallel HeapSort and Parallel MergeSort on Multicores systems.

Parallel Sort Library uses my Thread Pool Engine and sort many array parts - of your array -  in parallel using Quicksort or HeapSort or MergeSort and after that it finally merge them - with the merge() procedure -

In the previous parallelsort version i have parallelized only the sort part, but in this new parallelsort version i have parallelized also the merge procedure part and it gives better performance.

I have implemented a Parallel hybrid divide-and-conquer merge algorithm that performs 0.9-5.8 times better than sequential merge, on a quad-core processor, with larger arrays outperforming by over 5 times. Parallel processing combined with a hybrid algorithm approach provides a powerful high performance result.

The best case complexity of ParallelSort using mergesort  is:

 ((n/p)* log(n/p)) + O(n/p)

p: is the number of cores

the ((n/p)* log(n/p)) is the complexity of the sorting part.

O(n/p) is the best case complexity of the merging part.

so the best case complexity  is:  ((n/p)* log(n/p))

The worst case complexity of parallel sort library using mergesort is:

 ((n/p)* log(n/p)) +  O(n)

the ((n/p)* log(n/p)) is the complexity of the sorting part.

O(n) is the worst  case complexity of the merging part.

so the worst case complexity of parallelsort using mergesort is approximatly: O(n)

I have done some tests with my ParallelSort library and i have noticed that it can give up to 3.8x scalability with strings, and it gives 3x scalability with integers on a quad cores.

So, why it scales to 3.8x with strings and only 3x with integers on a quad cores ?


I explain:

In the SequentialMerge() method and QSort() method inside Parallel Sort library, i am calling the Scompare() method and also in both of them i am copying to the memory system.

So when i am using strings the SCompare() method is more expensive, so the parallel part p in the Amdahl equation 1/ S + P/N (S: the serial part, P: parallel part and N: the number of cores) is bigger than with integers so the Amdahl equation will scale better, but when we are using integers the SCompare() method is less expensive than the SCompare() with strings, so the parallel part p in the Amdahl equation is less bigger than with strings. so this is why parallel sorting with strings scales better than with integers.

I have implemented mergsort and quicksort, but as you know the complexity of mergesort in the worst case is better than quicksort , and the mergesort that i have implemented is faster than quicksort, but mergesort takes more space..

The reccurence equation of the complexity of mergesort is:

T(n) = 2 * T(n/2) + n

cause it take O(n) for the merging part.

It gives:

T(n) = 2 * T(n/2) + n

= 2 (2T(n/4) +n/2) + n

=4T(n/4)+n+n

=4T(n/4)+2*n

=4 (2T(n/8) +n/4) + 2*n

=8T(n/8)+n+2n

=8T(n/8)+3*n

=2k T(n/2^k) + k*n

We want:

n/2^k = 1

n = 2^k

log n = k

so the reccurence equation gives:

= n*T(1) +n*log(n)

= n+ (n * log(n))

So the mergesort complexity in the best case and in the worst case is:

n * log(n)

But the complexity of the quicksort in the worst case is:

T(n)= n + T(n-1)

it gives:

T(n) = n + (n-1) + T(n-2)

T(n) = n + (n-1) + (n-2)+ T(n-3)

T(n) = 1 + 2+ 3+.+N

.T(n) = O(n^2)

And Quicksort in best case performance is:
 
T(n) = T(n/2) + T(n/2) + O(n)
       = 2T(n/2) + (n)

this gives: T(n) = (n lg n)

Parallelizing the Sorts

One way to parallelize the sorts is:

1. Divide the data among the processors
2. Sort the data on the individual processors.
3. Merge the various data

Note that the merge operation is a reduction operation !

I have done some scalability tests on my parallelsort library and i have come to the conclusion that parallel heapsort is better on scalability than parallel quicksort cause the P part (of the Amdahl equation) is bigger in parallel heapsort
than in parallel quicksort, the parallel heapsort is doing more on the parallel part, it's why it scales better than parallel quicksort, but parallel quicksort is still faster than parallel heapsort on my tests on a quad core processor.

And please look at test.pas a parallel quicksort on many cores - compile and execute it...

Language: FPC Pascal v2.2.0+ / Delphi 7+: http://www.freepascal.org/

Operating Systems: Win , Linux and Mac (x86).

Required FPC switches: -O3 -Sd -dFPC -dWin32 -dFreePascal

-Sd for delphi mode....

Required Delphi switches: -DMSWINDOWS -$H+

For Delphi use -DDelphi

Click here to download the zip file: Zip


Description:

Distributed Reader-Writer Mutex, based on the Dmitry Vyukov C++ Distributed Reader-Writer Mutex , that works across processe and threads, I have included the following Reader-Writer Mutexes inside this Distributed Reader-Writer mutex:

TMREW a light weight MREW lock (multiple-readers-exclusive-writer lock) that is very fast and that works across processes and threads and TMultiReadExclusiveWrite from JCL and now both of them can scale better, and i have modified the Dmitry Vyukov Distributed Reader-Writer Mutex, in the first version i have used GetCurrentProcessorNumber(), and i have also provided you with a second version that scales better, to be able to use the second version please use the version2 inside defines.inc, i have given you a test.pas example for the first version and test1.pas for the second version, but don't forget to use version2 inside defines.inc, to use the second version just uncomment the version2 inside defines.inc and comment version1. I have also done a cache line alignement in TOmniMREW, this has allowed Drwlock to scale better.

I have provided you with the source code, please take a look at the source code to understand better.The Object Pascal Distributed Reader-Writer Mutex  is based on the following C++ Distributed Reader-Writer Mutex by Dmitry Vyukov, read more here:

http://www.1024cores.net/home/lock-free-algorithms/reader-writer-problem/distributed-reader-writer-mutex

You have four methods:

procedure wlock; // same as EnterWriteLock of TOmniMREW
procedure wunlock; // same as ExitWriteLock
procedure rlock; // same as EnterReadLock
procedure runlock; // same as ExitReadLock

Here is some scalability numbers:

I have used TOmniMREW of the Omnithread library and used only EnterReadLock() and ExitReadLock() with four threads on a quad cores and TOmniMREW gave a negative scalability of -5.51x

And when i have used the second version of Distributed Reader-Writer Mutex using only rlock() and runlock() , it gave me +3.94x scalability with four threads on four cores. So now it's scaling.

And about the second version , don't forget to initialize the number  that you pass to rlock() and runlock()  to 0 before calling  rlock() and runlock() .

In the previous versions i have aligned the array elements on cache line bounderies like have done Dmitry Vyukov, and when i have tested the second version it didn't work correctly , so i have thought about that and after that i have decided to not align the array elements on cache line bounderied but just add a cache line padding to TOmniMREW and this time it has worked perfectly and now the second version is scaling perfectly..

Language: FPC Pascal v2.2.0+ / Delphi 7+: http://www.freepascal.org/

Operating Systems: Win and Linux (x86).

Required FPC switches: -O3 -Sd -dFPC -dWin32 -dFreePascal

-Sd for delphi mode....

Required Delphi switches: -DMSWINDOWS -$H+

For Delphi use -DDelphi

And inside defines.inc you can use the following defines:

{$DEFINE CPU32} for 32 bits systems

{$DEFINE CPU64} for 64 bits systems

{$DEFINE TOmniMREW} to use Omnithread MREW

{$DEFINE TMultiReadExclusiveWrite} to use the jcl TMultiReadExclusiveWrite

Author: Amine Moulay Ramdane


Click here to download the zip file: Zip


Description:

Parallel BucketSort.

Bucket sort is not a sorting algorithm itself, rather it is a procedure for partitioning data to be sorted using some given sorting algorithm—a ”meta-algorithm” so to speak. Bucket sort will be better, when elements are uniformly distributed over an interval [a, b]  and buckets have not significantly different number of elements.

bucketsort sequential best case computational complexity using quicksort is = p × (n/p) log(n/p) = n log(n/p)

bucket sort parallel best case computational complexity using quicksort = (n/p) log(n/p)

Parallel BucketSort can scale better than my parallel quicksort and it can be much faster than my parallel quicksort. I have thought about my parallel quicksort , and i have found that parallel quicksort is fine but the problem with it is that the partition function is not parallelizable , so i have thought about this and i have decided to write a parallel BucketSort,and this parallel bucketsort can give you much better performance than parallel quicksort , just test it yourself and see, parallel bucketsort can sort just strings at the moment, and it can use quicksort or mergesort, mergesort is faster.

And please look at test.pas a parallel bucketsort on many cores - compile and execute it...

Language: FPC Pascal v2.2.0+ / Delphi 7+: http://www.freepascal.org/

Operating Systems: Win , Linux and Mac (x86).

Required FPC switches: -O3 -Sd -dFPC -dWin32 -dFreePascal

-Sd for delphi mode....

Required Delphi switches: -DMSWINDOWS -$H+

For Delphi use -DDelphi

Author: Amine Moulay Ramdane


Click here to download the zip file: Zip


Description:

Parallel Quicksort using the median-of-three..

In this new version i have changed the partition() function and also i have used the median of three method so that it avoids the worst case performance.

Parallel Quicksort is an implementation of the median-of-three that gives almost 10% better speed.

Parallel Quicksort gave me almost 3x scaling when sorting strings and integers on a quad cores, and you can use it also in an hybrid manner with mergsort, just by passing ctmergesort to the constructor it will give 10% better speed.

And as you know , Quicksort is a divide and conquer algorithm that have the following best case performance:

T(n) = T(n/2) + T(n/2) + O(n)
= 2T(n/2) + (n)

cause it take O(n) for the partition part.

It gives:

= 2 (2T(n/4) +n/2) + n
=4T(n/4)+n+n
=4T(n/4)+2*n
=4 (2T(n/8) +n/4) + 2*n
=8T(n/8)+n+2n
=8T(n/8)+3*n
=2k T(n/2^k) + k*n

We want:

n/2^k = 1
n = 2^k
log n = k

so the reccurence equation gives:

= n*T(1) +n*log(n)
= n+ (n * log(n))

So the quicksort complexity in the best case is:

n * log(n)

And please look at test.pas a parallel quicksort on many cores - compile and execute it...

Language: FPC Pascal v2.2.0+ / Delphi 7+: http://www.freepascal.org/

Operating Systems: Win , Linux and Mac (x86).

Required FPC switches: -O3 -Sd -dFPC -dWin32 -dFreePascal

-Sd for delphi mode....

Required Delphi switches: -DMSWINDOWS -$H+

For Delphi use -DDelphi

Author: Amine Moulay Ramdane


Click here to download the zip file: Zip


Description:

The Parallel implementation of Conjugate Gradient Linear System Solver that i programmed here is designed to be used to solve large sparse systems of linear equations where the direct methods can exceed available machine memory and/or be extremely time-consuming. for example the direct method of the Gauss algorithm takes O(n^2) in the back substitution process and is dominated by the O(n^3) forward elimination process, that means, if for example an operation takes 10^-9 second and we have 1000 equations , the elimination process in the Gauss algorithm will takes 0.7 second, but if we have 10000 equations in the system , the elimination process in the Gauss algorithm will take 11 minutes !. This is why i have develloped for you the Parallel implementation of Conjugate Gradient Linear System Solver in Object Pascal, that is very fast.

You have only one method to use that is Solve()

function TParallelConjugateGradient.Solve(var A: arrarrext;var B,X:VECT;var
RSQ:DOUBLE;nbr_iter:integer;show_iter:boolean):boolean;

The system: A*x = b

The important parameters in the Solve() method are:

A is the matrix , B is the b vector, X the initial vector x,

nbr_iter is the number of iterations that you want

and show_iter to show the number of iteration on the screen.

RSQ is the sum of the squares of the components of the residual vector
A.x - b.


I have got over 3X scalability on a quad core.

The Conjugate Gradient Method is the most prominent iterative method for solving sparse systems of linear equations. Unfortunately, many textbook treatments of the topic are written with neither illustrations nor intuition, and their victims can be found to this day babbling senselessly in the corners of dusty libraries. For this reason, a deep, geometric understanding of the method has been reserved for the elite brilliant few who have painstakingly decoded the mumblings of their forebears. Conjugate gradient is the most popular iterative method for solving large systems of linear equations. CG is effective for systems of the form A.x = b where x is an unknown vector,
b is a known vector, A is a known square, symmetric, positive-definite (or positive-indefinite) matrix. These systems arise in many important settings, such as finite difference and finite element methods for solving partial differential equations, structural analysis, circuit analysis, and math homework

The Conjugate gradient method can also be applied to non-linear problems, but with much less success since the non-linear functions have multiple minimums. The Conjugate gradient method will indeed find a minimum of such a nonlinear function, but it is in no way guaranteed to be a global minimum, or the minimum that is desired.
But the conjugate gradient method is great iterative method for solving large, sparse linear systems with a symmetric, positive, definite matrix.

In the method of conjugate gradients the residuals are not used as search directions, as in the steepest decent method, cause searching can require a large number of iterations as the residuals zig zag towards the minimum value for ill-conditioned matrices. But instead conjugate gradient method uses the residuals as a basis to form conjugate search directions . In this manner, the conjugated gradients (residuals) form a
basis of search directions to minimize the quadratic function f(x)=1/2*Transpose(x)*A*x + Transpose(b)*x and to achieve faster speed and result of dim(N) convergence.

Jacobi serial complexity is O(N^2) and Conjugate gradient serial complexity is O(N^3/2).

Please look at the test.pas example inside the zip file, compile and execute it...

Language: FPC Pascal v2.2.0+ / Delphi 7+: http://www.freepascal.org/

Operating Systems: Win , Linux and Mac (x86).

Required FPC switches: -O3 -Sd -dFPC -dWin32 -dFreePascal

-Sd for delphi mode....

-dUnix for Linux,MacOSX etc.

Required Delphi switches: -DMSWINDOWS -$H+ -DDelphi

And inside defines.inc you have two defines:

{$DEFINE CPU32} for 32 bits systems

{$DEFINE CPU64} for 64 bits systems

Parallel implementation of Jacobi with relaxation Linear System Solver version 1.01

Author: Amine Moulay Ramdane


Click here to download the zip file: Zip


Description:

The Parallel iterative with relaxation method that i programmed here is designed to be used to solve large sparse systems of linear equations where the direct methods can exceed available machine memory and/or be extremely time-consuming. for example the direct method of the Gauss algorithm takes O(n^2) in the back substitution process and is dominated by the O(n^3) forward elimination process, that means, if for example an operation takes 10^-9 second and we have 1000 equations , the elimination process in the Gauss algorithm will takes 0.7 second, but if we have 10000 equations in the system , the elimination process in the Gauss algorithm will take 11 minutes !. This is why i have develloped for you the Parallel Jacobi with relaxation iterative algorithm in Object Pascal, that is very fast.

Please read more here: ParallelJacobiWithRelaxation

Please look at test.pas example inside the zip file, compile and execute it...

Language: FPC Pascal v2.2.0+ / Delphi 7+: http://www.freepascal.org/

Operating Systems: Win , Linux and Mac (x86).

Note: to be able to port to Linux and Mac OSX you have to compile the dynamic libraries...

Required FPC switches: -O3 -Sd -dFPC -dWin32 -dFreePascal

-Sd for delphi mode....

-dUnix for Linux,MacOSX etc.

Required Delphi switches: -DMSWINDOWS -$H+ -DDelphi

And inside defines.inc you can use the following defines:

{$DEFINE CPU32} and {$DEFINE Win32} for 32 bits systems

{$DEFINE CPU64} and {$DEFINE Win64} for 64 bits systems

Author: Amine Moulay Ramdane


Click here to download the zip file: Zip


Description:

Parallel Compression library using the Zlib algorithm and my Thread Pool Engine.

- Now my ParallelZlb gives 5% better performance than Pigz.

- It supports memory streams, file streams and files

- 64 bit supports - lets you create archive files over 4 GB , 
  supports archives up  to 2^63 bytes, compresses and 
  decompresses files up to 2^63 bytes.

- Parallel compression and parallel decompression are extremely fast

- It supports both compression and decompression rate indicator

- You can test your compressed file

- Easy programming interface

- Full source codes available.


Please look at test_pzlib.pas inside the zip file, compile and execute it.. -

Language: FPC Pascal v2.2.0+ / Delphi 7+: http://www.freepascal.org/

Operating Systems: Win , Linux and Mac (x86).

Note: to be able to port to Linux and Mac OSX you have to compile the dynamic libraries...

Required FPC switches: -O3 -Sd -dFPC -dWin32 -dFreePascal

-Sd for delphi mode....

-dUnix for Linux,MacOSX etc.

Required Delphi switches: -DMSWINDOWS -$H+ -DDelphi

Authors: Amine Moulay Ramdane(Parallel parts) and Barry Kelly (HashList).


Click here to download the zip file: Zip


Language: FPC Pascal v2.2.0+ / Delphi 5+: http://www.freepascal.org/

Operating Systems: Win , Linux and Mac (x86).

Description:

A parallel HashList with O(1) best case and O(log(n)) worst case access that uses lock striping and lightweight MREWs(multiple-readers-exclusive-writer) , this allows multiple threads to write and read concurently. also parallelhashlist maintains an independant counter , that counts the number of entries , for each segment of the hashtable and uses a lock for each counter, this is also for better scalability.

I have tested ParallelHashlist with four threads on a quad core and it's giving a perfect scaling on both reads and writes.

Note: When i have done those benchmarks , there was not enough/much items organized as a self-balancing tree in the individual chains of the hashtable, so , almost all the items was found and inserted in O(1) , so the parallel part in the Amdahl equation was not much bigger compared to to the serial part. But you will notice in pratice that as soon as you will have more items on the chains of the Hash table , organized as self-balancing tree, with a worst case log(n)  , the parallel part will become bigger in the Amdahl equation and you will have better scalability.

Parallel Hashlist was updated to version 1.44 , In the previous version i have set the number of lightweight MREWs(multiple-readers-exclusive-writer) to 128 but i have decided to change that in version 1.44  so that you can give a variable number of MREWS, this will scale better and now the constructor will look like this:

 hash:=TParallelHashList.create(trait, Hashsize, number_of_MREWS);

and the number_of_MREWS must be less or equal to the Hashsize

and please pass a hashsize and the number of mrews in power of 2 to the constructor by using the shl operation for example like this

trait:=TCaseinsensitiveTraits.create;;
hash1:=TParallelHashList.create(trait,1 shl 25,1 shl 25);

Why do you have to use a power of 2 ?

Please read this:

"Power-of-Two Hash Table Size

Any data structures 101 book will say choose a prime for the number of buckets, so that the bucket's index can easily be computed by h(k) = k mod m, where k is the key value and m is the bucket size. While this approach is straight-forward, there are a number of issues with it, including slow modulo performance. ConcurrentHashMap instead uses a power-of-two rule

http://work.tinou.com/2008/09/performance-optimization-in-concurrenthashmap.html "


I am using modulo functions inside parallelhashlist, so it's better to use hashsize and the number of MREWs(multiple-readers-exclusive-writer) in power of 2 ,  this will make the modulo function of the delphi and freepascal compilers 10X faster.

Required FPC switches: -O3 -Sd -dFPC -dFreePascal

-Sd for delphi mode....

Required Delphi switches: -DMSWINDOWS -$H+

For Delphi 5,6,7 use -DDelphi

For Delphi 2005,2006,2007,2009,2010+ use the switch -DDELPHI2005

Click here to download the zip file: Zip


Language: FPC Pascal v2.2.0+ / Delphi 5+: http://www.freepascal.org/

Operating Systems: Win , (x86).

Description:

Linear programming modeling examples in Object Pascal. Please look inside the zip at the example SP.pas (shortest-path problem) in Object Pascal, i have provided you with the LPSolve library, but the examples that i have included do generate and MPS file , so you can use a faster software than LPSolve , example SCIP or CLP from COIN-OR , and just pass them the MPS ouput file that the LPSolve library does generate and they will execute them without any problem...

Please look more information here: Linear Programming.

Required FPC switches: -O3 -Sd -dFPC -dWin32 -dFreePascal

-Sd for delphi mode....

Required Delphi switches: -DMSWINDOWS -$H+ -DDelphi

Lockfree MPMC and SPMC fifo queues version 1.13

Click here to download the zip file: Zip


Language: FPC Pascal v2.2.0+ / Delphi 5+: http://www.freepascal.org/

Operating Systems: Win , Linux and Mac (x86).

Description:

Lock-free SPMC algorithm to handle queue FIFO proposed by Amine Moulay Ramdane, use only single CAS on pop and no CAS on push. You can use it in a work-stealing manner with a local queue for each server thread to optimize for more throuput and minimize contention.

and

Lock-free MPMC algorithm to handle queue FIFO proposed by Dariusz Mazur (and modified by Amine Moulay Ramdane), use only single CAS on pop and single CAS on push.

I have done some acalability tests and it's not scaling cause when you are using a single thread some variable are updated on the L1  cache but using multiple threads those variables are loaded from the L2 cache and it's more expensive to load them from the L2 cache. But even though lockfree_mpmc is not scalable, you can   increase the P (parallel) part by doing more of the same: Increase the volume of data processed by the P part (and therefore the percentage p of time spent in computing). This is Gustafson's Law and you will get more scalability.

For example i have used the IntToStr() function on each of the four threads (on a quad core) on my lockfree_mpmc test programs to convert from and integer to a string, so i have increased the P (parallel) part and i have got more scalability, this is Gustafson's Law, and you have to remember Gustafson's Law , this is very important.

Please look more information here: Lock-free MPMC.

Required FPC switches: -O3 -Sd -dFPC -dWin32 -dFreePascal

-Sd for delphi mode....

Required Delphi switches: -DMSWINDOWS -$H+ -DDelphi

Author: Amine Moulay Ramdane


Click here to download the zip file: Zip


Language: FPC Pascal v2.2.0+ / Delphi 5+: http://www.freepascal.org/

Operating Systems: Win , Linux and Mac (x86).

Description:

Lock-free MPMC and SPMC priority FIFO queues. They use 0(1) on enqueue and 0(3) worst case on dequeue

Required FPC switches: -O3 -Sd -dFPC -dWin32 -dFreePascal

-Sd for delphi mode....

Required Delphi switches: -DMSWINDOWS -$H+

For Delphi 5,6,7 use -DDelphi

For Delphi 2005,2006,2007,2009,2010+ use the switch -DDELPHI2005+

Click here to download the zip file: Zip


Language: FPC Pascal v2.2.0+ / Delphi 5+: http://www.freepascal.org/

Operating Systems: Win , Linux and Mac (x86).

Description:

Parallel FIFO MPMC queue algorithm that uses a spinlock and an exponential backoff.

Please look at the benchmarks against lockfree fifo queues: FIFO MPMC queue.

Required FPC switches: -O3 -Sd -dFPC -dWin32 -dFreePascal

-Sd for delphi mode....

Required Delphi switches: -DMSWINDOWS -$H+

For Delphi 5,6,7 use -DDelphi

For Delphi 2005,2006,2007,2009,2010+ use the switch -DDELPHI2005+

Author: Amine Moulay Ramdane


Click here to download the zip file: Zip


Description:

It's harder and sometimes impossible to get analytical results about waiting times and queue length for general interarrival and service distributions; so, it's important to be able to estimate these quantities by observing the results of simulation.

It's very easy in Object Pascal to simulate a sequence of arrival times with a given interarrival distribution.

Look at the examples MM1.pas( M/M/1 queuing model) and MMn.pas(M/M/n - n: number of servers -) inside the zip file:

---------------------------

InterArrivals:=TExponentialDistribution.Create(420623,1.0/3.0);

ServiceTimes:=TExponentialDistribution.Create(220623,1.0/4.0);

currtime:=0.0;

for i:=1 to simnumber

do

begin

obj:=TJob.create;

obj.simnumber:=simnumber;

obj.number:=i;

currtime:=currtime+InterArrivals.Sample;

obj.ArrivalTime:=currtime;

obj.Servicetime:= ServiceTimes.sample;

TP.execute(myobj.myproc1,pointer(obj),NORMAL_PRIORITY);

end;

-------------------------------------------

Here we have the InterArrivals object and ServiceTimes object and we are calling InterArrivals.Sample to get our samples from the Exponential Distribution.

After that we are calling myobj.myproc1 to simulate our M/M/1 queuing model...

If you look at MMn.pas , you will see that the arrival rate is: 3 and the service rate is 4 , so, this will give us a theoretical value of 1/(4-3) = 1 for one server, and the Object Pascal simulation gave me 1.02 for one server.

Language: FPC Pascal v2.2.0+ / Delphi 7+: http://www.freepascal.org/

Operating Systems: Win , Linux and Mac (x86).

Required FPC switches: -O3 -Sd -dFPC -dWin32 -dFreePascal

-Sd for delphi mode....

Required Delphi switches: -DMSWINDOWS -$H+

For Delphi 5,6,7 use -DDelphi

For Delphi 2005,2006,2007,2009,2010+ use the switch -DDELPHI2005+

Author: Amine Moulay Ramdane


Click here to download the zip file: Zip


Description:

Drop-Down Menu widget using the Object Pascal CRT unit. Please look at the test.pas example inside the zip file.

Use the 'Delete' on the keyboard to delete the items
Use the 'Insert' on the keyboard to insert the items
and use the 'Up' and 'Down' and 'PageUp and 'PageDown' to scroll ..
and use the 'Tab' on the keyboard to switch between the Drop Down Menus
and 'Enter' to select an item..
and the 'Esc' on the keyboard to exit..
and the 'F1' on keyboard to delete all the items from the list

Language: FPC Pascal v2.2.0+ / Delphi 7+: http://www.freepascal.org/

Operating Systems: Windows, Mac OSX , Linux , Unix...

Required FPC switches: -O3 -Sd -dFPC -dFreePascal

-Sd for delphi mode....

-dUnix for Linux , Unix and Mac OSX

-dWindows for windows

Required Delphi switches: -DMSWINDOWS -$H+

For Delphi 5,6,7 use -DDelphi switch

For Delphi 2005,2006,2007,2009,2010+ use the switch -DDELPHI2005+

Authors: Amine Moulay Ramdane,Marcel van Brakel ,Olivier Sannier ,Matthias Thoma,Florent Ouchet.Robert Marquardt.

Click here to download the zip file: Zip


Description:

The following classes have been added to the Synch module: TCriticalSection,TMutex,TSimpleEvent,TSemaphore,TMultiReadExclusiveWrite.

Note: I have modified a little bit the TJclMultiReadExclusiveWrite from the Jedi code Library and rename it TMultiReadExclusiveWrite. TCriticalSection,TMutex,TSimpleEvent,TSemaphore are not from JCL

Language: FPC Pascal v2.2.0+ / Delphi 7+: http://www.freepascal.org/

Operating Systems: Windows, Mac OSX , Linux , Unix...

Required FPC switches: -O3 -Sd -dFPC -dFreePascal

-Sd for delphi mode....

-dUnix for Linux , Unix and Mac OSX

-dWindows for windows

Required Delphi switches: -DMSWINDOWS -$H+

For Delphi 5,6,7 use -DDelphi switch

For Delphi 2005,2006,2007,2009,2010+ use the switch -DDELPHI2005+

Author: Amine Moulay Ramdane


Click here to download the zip file: Zip


Description:

Why the 2 GB limitation on the Win 32bits systems ?

My AWE object pascal module is here, it allows your application to use up to 64GB of RAM.

And here is the public interfaces of TAWEMem and TAWEStream classes, i have implemented the following methods:

TAWEStream = class

public

Memory:pointer;
allocated:boolean;
Size:longword;
position:longint;
PageSize:integer;

constructor Create(ulBytes: longint);
destructor Destroy(); override;

function HowManyPagesAllocated(): ulong;
function Seek(Offset: longint; Origin: Word): longint;
function CopyFrom(in_stream:TStream;count:longint):longint;
function CopyTo(out_stream:TStream;count:longint):longint;
function Read(var Buffer;count:longint):longint;
function Write(const Buffer;count:longint):longint;
procedure LoadFromStream(in_stream: TStream);
procedure LoadFromFile(const FileName: string);
function ToString:string;

published

property TotalMem:int64 read gettotalmem;
property AvailMem:int64 read getavailmem;
property MemLoad:int64 read getmemload;

end;

TAWEMem = class

public

memory:pointer;
allocated:boolean;
Size:lonword;
PageSize:integer;

constructor Create(ulBytes: ULONG);
destructor Destroy(); override;
function HowManyPagesAllocated(): ULONG;

end;

Note: To be able to use AWE you have to set the user rights correctly, so, go to:

Control Panel -> Administrative tools -> Local Security Policy -> User Rights Assignment and give 'Lock pages in memory' right to the user that wants to use AWE and reboot the system..

Every TAWEMem object can go up to 4GB of memory and every TAWEStream can go up to 2GB of memory, and you can go up to 64GB of memory !

And please look at the test examples 'test.pas' and 'test1.pas' inside the zipfile - compile and execute them... -

Language: FPC Pascal v2.2.0+ / Delphi 7+: http://www.freepascal.org/

Operating Systems: Windows 2000 and up (x86).

Required FPC switches: -O3 -Sd -dFPC -dWin32 -dFreePascal

-Sd for delphi mode....

Required Delphi switches: -DMSWINDOWS -$H+

For Delphi 5,6,7 use -DDelphi

For Delphi 2005,2006,2007,2009,2010+ use the switch -DDELPHI2005+

Author: Amine Moulay Ramdane


Click here to download the zip file: Zip


Language: FPC Pascal v2.2.0+ / Delphi 5+: http://www.freepascal.org/

Operating Systems: Win , Linux and Mac (x86).

Description:

Thread Pool Engine.

Please read an article that i wrote about my Threadpool engine: article.

The following have been added:

• Lockfree ParallelQueue for less contention and more efficiency or it can use lockfree_mpmc - flqueue that i have modified, enhanced and improved... -
• A lock-free queue for each worker thread and it uses work-stealing - for more efficiency -
• Enters in a wait state when there is no job in the queue - for more efficiency -
• You can distribute your jobs to the workers threads and call any method with the threadpool's execute() method.

Look into defines.inc there is many options:


Lockfree_MPMC: it uses lockfree_MPMC
RingBuffer: it uses lock-free RingBuffer
SINGLE_PRODUCER: for a single producer (thread)
MUTIPLE_PRODUCER: mutiple producer (threads)
CPU32: for 32 bits architecture

Required FPC switches: -O3 -Sd -dFPC -dWin32 -dFreePascal

-Sd for delphi mode....

Required Delphi switches: -DMSWINDOWS -$H+

For Delphi 5,6,7 use -DDelphi

For Delphi 2005,2006,2007,2009,2010+ use the switch -DDELPHI2005+

Please look at the examples test.pas,testpool.pas and test_thread.pas...

Note: testpool.pas is a parallel program of a Matrix multiply by a vector that uses SSE+ and it requires Delphi 5+. test.pas and test_thread.pas works with both FreePascal and Delphi.

Author: Amine Moulay Ramdane


Click here to download the zip file: Zip


Language: FPC Pascal v2.2.0+ / Delphi 5+: http://www.freepascal.org/

Operating Systems: Win , Linux and Mac (x86).

Description:

Thread Pool Engine.

The following have been added:

- You can give the following priorities to jobs:

LOW_PRIORITY
NORMAL_PRIORITY
HIGH_PRIORITY

- Lockfree ParallelQueue for less contention and more efficiency or it can use lockfree_mpmc - flqueue that i have modified, enhanced and improved... -

- A lock-free queue for each worker thread and it uses work-stealing - for more efficiency -

- Enters in a wait state when there no is job in the queue - for more efficiency -

- You can distribute your jobs to the workers threads and call any method with the threadpool's execute() method.

- Uses 0(1) on enqueue and 0(3) worst case on dequeue.

Look into defines.inc there is many options:

CPU32: for 32 bits architecture
MUTIPLE_PRODUCER: mutiple producer (threads)
SINGLE_PRODUCER: for a single producer (thread)

Required FPC switches: -O3 -Sd -dFPC -dWin32 -dFreePascal

-Sd for delphi mode....

Required Delphi switches: -DMSWINDOWS -$H+

For Delphi 5,6,7 use -DDelphi

For Delphi 2005,2006,2007,2009,2010+ use the switch -DDELPHI2005+

Please look at the examples test.pas,testpool.pas and test_thread.pas...

Note: testpool.pas is a parallel program of a Matrix multiply by a vector that uses SSE+ and it requires Delphi 5+. test.pas and test_thread.pas works with both FreePascal and Delphi.

Author: Amine Moulay Ramdane


Click here to download the zip file: Zip

Language: Delphi 5+

Operating Systems: NT/2000/XP and above.

Description:

Parallel program of Matrix multiply by a vector that uses SSE+ and my Lock-free Threadpool. Please look at the example testpool.pas inside the zip file...

This demonstration does use SSE+ , so if you don't have SSE support it will not work. It does work with P4 and above.

Required FPC switches: -O3 -Sd -dFPC -dWin32 -dFreePascal

-Sd for delphi mode....

Required Delphi switches: -DMSWINDOWS -$H+

For Delphi 5,6,7 use -DDelphi

For Delphi 2005,2006,2007,2009,2010+ use the switch -DDELPHI2005+

Click here to download the zip file: Zip


Language: FPC Pascal v2.2.0+ / Delphi 5+: http://www.freepascal.org/

Operating Systems: NT/2000/XP and above

Description:

TLFMemoryStream is like the Freepascal and Delphi TMemoryStream, but it's Lock-free: it mean that it's scalable and ready for multicores. Use the Lock-Free TLFMemoryStream to store data in a dynamic memory buffer that is enhanced with file-like access capabilities. TLFMemoryStream provides the general I/O capabilities of a stream object while introducing methods and properties to manage a dynamic memory buffer. Memory streams are useful as intermediary objects that can hold information as well as read it from or write it to another storage medium. They provide a useful format for comparing the contents of streams, or for manipulating data that is stored in a less accessible medium.

The zip file also include TAsyncFileStream - asynchronous file input/output in Windows NT. Please read AFS.txt inside the zip.

Required FPC switches: -O3 -Sd -dFPC -dWin32 -dFreePascal

-Sd for delphi mode....

Required Delphi switches: -DMSWINDOWS -$H+

For Delphi 5,6,7 use -DDelphi

For Delphi 2005,2006,2007,2009,2010+ use the switch -DDELPHI2005+

Language: Perl: http://www.activestate.com

With this module you can import and call arbitrary functions from Win32's Dynamic Link Libraries (DLL).

API module for ActivePerl 5.10: Zip

Operating Systems: Windows 95/98/Me/NT/2000/XP

How to install:

Please read the readme file inside the zipfile.

Click here to download the zip file: Exe


Description:

With this object oriented Perl module you will be able to monitor the changes on your directories, this allows your Perl application to respond to changes in the file system, such as new file and/or directory creation, renaming, size, attribute, time, security-descriptor changes etc. Also, with AdvNotify you can run multiple threads from inside your Perl application to monitor the file system changes and you will be notified of wich file has been changed. The AdvNotify's interface has been carefully designed to be very easy to use.

Note: AdvNotify does use asynchronous completion to receive notification from the WinNT OS (no wasting CPU time "polling"), hence AdvNotify is very efficient. This module needs the API module, please download and install the API module before installing AdvNotify.

Perl: ActivePerl: 5.0050x, 5.6 or higher.

Operating Systems: Windows NT/2000/XP

How to install: Read the readme file inside the zip.

Documentation:

After installing AdvNotify, click on your \perl\html\index.html and scroll down to the Win32 links and you will find it there, or you can also access it directly from \perl\html\lib\win32\AdvNotify.html or from Start => Programs => ActivePerl (documentation).

Doc

This object oriented Perl module implements a high level interface to the NTFS filesystem.

Please take a look at the documentation..

Perl: ActivePerl: 5.0050x, 5.6 or higher.

Operating System: Windows 2000/XP

Note: This module needs the API module, please download and install the API module before installing NTFS.

Click here to download the zip file: Zip


Description:

Shared memory is very important for client-server application developers and is also the fastest mechanism by wich server developers can etablish (local) interprocess communication between the cooperating tasks of an application program, often server applications are designed as a set of processes and threads, these tasks must use some kind of interprocess-communication mechanisms to communicate data and coordinate processing between each other, for example: TCP/IP,Pipes,Shared memory etc., but shared memory is the fastest one. This object oriented Perl module will allow you to map both memory and files into virtual address space, processes or threads can gain access to mapped memory via naming mechanism. If for example one process writes a data into a particular region of shared memory the other processes see it immediatly hence shared memory does avoid system space buffering and slow I/O operations, also shared memory will take benefit of the underlying VM paging mechanism and it will improve the memory access time (pages hits,locked memory regions). Any data structure you want can be embeded in a shared memory area and thus made accessible to multiple processes. This gives you the flexibility to create any communication structure you desire, both text and binary data are supported by this module.

Perl: ActivePerl: 5.0050x, 5.6 or higher.

Operating Systems: Windows 95/98/Me/NT/2000/XP

Note: This module needs the API module, please download and install the API module before installing MemMap.

Doc

Click here to download the zip file: Zip


Description:

This object oriented Perl module implements the Win32 synchronisation mechanisms: Semaphore,Mutex, Event,Timer objects.

Perl: ActivePerl: 5.0050x, 5.6 or higher.

Operating Systems: Windows 95/98/Me/NT/2000/XP

Note: This module needs the API module, please download and install the Perl API module before installing ISync.

Doc

More to come,Thank you.