Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-11-20 14:30:57 +00:00
Code Issues Projects Releases Packages Wiki Activity
reactos/sdk/lib/skiplist/skiplist.h

55 lines
1.9 KiB
C
Raw Normal View History

[SKIPLIST] Add my implementation of an efficient Skiplist. A Skiplist can do insertion, deletion and lookups in O(log N) on average just like balanced trees. It features simpler algorithms though due to purely relying on probabilistic balancing at insertion and not on rebalancing with every modification. This simple structure allowed me to implement some additions on top of the standard algorithms: * Storing distances between elements on each level to efficiently return the index of the element in the Skiplist when doing a lookup. * InsertTailElementSkiplist to explicitly insert an element at the end of the Skiplist. This needs no comparisons and is useful when you can be sure that the new element would be inserted at the end (e.g. for a new print job in the queue with default priority). More features are easily possible, but for now I limited features on those needed for my Local Spooler work. Some references on Skiplists: * ftp://ftp.cs.umd.edu/pub/skipLists/skiplists.pdf * http://drum.lib.umd.edu/bitstream/1903/544/2/CS-TR-2286.1.pdf svn path=/branches/colins-printing-for-freedom/; revision=68191
2015-06-19 10:27:46 +00:00
/*
* PROJECT: Skiplist implementation for the ReactOS Project
[PRINTING] [SKIPLIST] Use the new header with SPDX license identifier and relicense the entire Printing Stack as well as its Skiplist dependency under GPL-2.0+ Previously, the Printing Stack was a mix of GPLed and LGPLed code. Having everything under GPL-2.0+ makes things consistent and allows me to import code from most Open Source licenses. Given that the Printing Stack components are exchangeable with their Windows counterparts and implement documented interfaces, this license change doesn't impose any additional restrictions on dependent components (like printer drivers). svn path=/trunk/; revision=75988
2017-09-29 17:18:19 +00:00
* LICENSE: GPL-2.0+ (https://spdx.org/licenses/GPL-2.0+)
[SKIPLIST] Add my implementation of an efficient Skiplist. A Skiplist can do insertion, deletion and lookups in O(log N) on average just like balanced trees. It features simpler algorithms though due to purely relying on probabilistic balancing at insertion and not on rebalancing with every modification. This simple structure allowed me to implement some additions on top of the standard algorithms: * Storing distances between elements on each level to efficiently return the index of the element in the Skiplist when doing a lookup. * InsertTailElementSkiplist to explicitly insert an element at the end of the Skiplist. This needs no comparisons and is useful when you can be sure that the new element would be inserted at the end (e.g. for a new print job in the queue with default priority). More features are easily possible, but for now I limited features on those needed for my Local Spooler work. Some references on Skiplists: * ftp://ftp.cs.umd.edu/pub/skipLists/skiplists.pdf * http://drum.lib.umd.edu/bitstream/1903/544/2/CS-TR-2286.1.pdf svn path=/branches/colins-printing-for-freedom/; revision=68191
2015-06-19 10:27:46 +00:00
* PURPOSE: Interfaces for the Skiplist
[PRINTING] [SKIPLIST] Use the new header with SPDX license identifier and relicense the entire Printing Stack as well as its Skiplist dependency under GPL-2.0+ Previously, the Printing Stack was a mix of GPLed and LGPLed code. Having everything under GPL-2.0+ makes things consistent and allows me to import code from most Open Source licenses. Given that the Printing Stack components are exchangeable with their Windows counterparts and implement documented interfaces, this license change doesn't impose any additional restrictions on dependent components (like printer drivers). svn path=/trunk/; revision=75988
2017-09-29 17:18:19 +00:00
* COPYRIGHT: Copyright 2015 Colin Finck (colin@reactos.org)
[SKIPLIST] Add my implementation of an efficient Skiplist. A Skiplist can do insertion, deletion and lookups in O(log N) on average just like balanced trees. It features simpler algorithms though due to purely relying on probabilistic balancing at insertion and not on rebalancing with every modification. This simple structure allowed me to implement some additions on top of the standard algorithms: * Storing distances between elements on each level to efficiently return the index of the element in the Skiplist when doing a lookup. * InsertTailElementSkiplist to explicitly insert an element at the end of the Skiplist. This needs no comparisons and is useful when you can be sure that the new element would be inserted at the end (e.g. for a new print job in the queue with default priority). More features are easily possible, but for now I limited features on those needed for my Local Spooler work. Some references on Skiplists: * ftp://ftp.cs.umd.edu/pub/skipLists/skiplists.pdf * http://drum.lib.umd.edu/bitstream/1903/544/2/CS-TR-2286.1.pdf svn path=/branches/colins-printing-for-freedom/; revision=68191
2015-06-19 10:27:46 +00:00
*/
#ifndef _REACTOS_SKIPLIST_H
#define _REACTOS_SKIPLIST_H
[SKIPLIST] The Park-Miller Lehmer Random Number Generator only outputs 31 uniformly distributed random bits. Bit 32 is always zero. Fix the code accordingly. This limits the maximum number of Skiplist levels to 31, but we only use 16 anyway so far. svn path=/branches/colins-printing-for-freedom/; revision=68991
2015-09-04 14:03:00 +00:00
// Define SKIPLIST_LEVELS to a value between 1 and 31 before including this header.
[SKIPLIST] Add my implementation of an efficient Skiplist. A Skiplist can do insertion, deletion and lookups in O(log N) on average just like balanced trees. It features simpler algorithms though due to purely relying on probabilistic balancing at insertion and not on rebalancing with every modification. This simple structure allowed me to implement some additions on top of the standard algorithms: * Storing distances between elements on each level to efficiently return the index of the element in the Skiplist when doing a lookup. * InsertTailElementSkiplist to explicitly insert an element at the end of the Skiplist. This needs no comparisons and is useful when you can be sure that the new element would be inserted at the end (e.g. for a new print job in the queue with default priority). More features are easily possible, but for now I limited features on those needed for my Local Spooler work. Some references on Skiplists: * ftp://ftp.cs.umd.edu/pub/skipLists/skiplists.pdf * http://drum.lib.umd.edu/bitstream/1903/544/2/CS-TR-2286.1.pdf svn path=/branches/colins-printing-for-freedom/; revision=68191
2015-06-19 10:27:46 +00:00
// This specifies the maximum number of levels you want your Skiplist to have.
// A value of X is recommended for handling up to 2^X elements.
#ifndef SKIPLIST_LEVELS
[SKIPLIST] The Park-Miller Lehmer Random Number Generator only outputs 31 uniformly distributed random bits. Bit 32 is always zero. Fix the code accordingly. This limits the maximum number of Skiplist levels to 31, but we only use 16 anyway so far. svn path=/branches/colins-printing-for-freedom/; revision=68991
2015-09-04 14:03:00 +00:00
#error Please define SKIPLIST_LEVELS to a value between 1 and 31.
[SKIPLIST] Add my implementation of an efficient Skiplist. A Skiplist can do insertion, deletion and lookups in O(log N) on average just like balanced trees. It features simpler algorithms though due to purely relying on probabilistic balancing at insertion and not on rebalancing with every modification. This simple structure allowed me to implement some additions on top of the standard algorithms: * Storing distances between elements on each level to efficiently return the index of the element in the Skiplist when doing a lookup. * InsertTailElementSkiplist to explicitly insert an element at the end of the Skiplist. This needs no comparisons and is useful when you can be sure that the new element would be inserted at the end (e.g. for a new print job in the queue with default priority). More features are easily possible, but for now I limited features on those needed for my Local Spooler work. Some references on Skiplists: * ftp://ftp.cs.umd.edu/pub/skipLists/skiplists.pdf * http://drum.lib.umd.edu/bitstream/1903/544/2/CS-TR-2286.1.pdf svn path=/branches/colins-printing-for-freedom/; revision=68191
2015-06-19 10:27:46 +00:00
#endif
[SKIPLIST] Verify that SKIPLIST_LEVELS is in the required range using C_ASSERTs (thanks to Thomas for the hint!) svn path=/branches/colins-printing-for-freedom/; revision=68192
2015-06-19 12:33:45 +00:00
C_ASSERT(SKIPLIST_LEVELS >= 1);
[SKIPLIST] The Park-Miller Lehmer Random Number Generator only outputs 31 uniformly distributed random bits. Bit 32 is always zero. Fix the code accordingly. This limits the maximum number of Skiplist levels to 31, but we only use 16 anyway so far. svn path=/branches/colins-printing-for-freedom/; revision=68991
2015-09-04 14:03:00 +00:00
C_ASSERT(SKIPLIST_LEVELS <= 31);
[SKIPLIST] Verify that SKIPLIST_LEVELS is in the required range using C_ASSERTs (thanks to Thomas for the hint!) svn path=/branches/colins-printing-for-freedom/; revision=68192
2015-06-19 12:33:45 +00:00
[SKIPLIST] Add my implementation of an efficient Skiplist. A Skiplist can do insertion, deletion and lookups in O(log N) on average just like balanced trees. It features simpler algorithms though due to purely relying on probabilistic balancing at insertion and not on rebalancing with every modification. This simple structure allowed me to implement some additions on top of the standard algorithms: * Storing distances between elements on each level to efficiently return the index of the element in the Skiplist when doing a lookup. * InsertTailElementSkiplist to explicitly insert an element at the end of the Skiplist. This needs no comparisons and is useful when you can be sure that the new element would be inserted at the end (e.g. for a new print job in the queue with default priority). More features are easily possible, but for now I limited features on those needed for my Local Spooler work. Some references on Skiplists: * ftp://ftp.cs.umd.edu/pub/skipLists/skiplists.pdf * http://drum.lib.umd.edu/bitstream/1903/544/2/CS-TR-2286.1.pdf svn path=/branches/colins-printing-for-freedom/; revision=68191
2015-06-19 10:27:46 +00:00
// Function pointer definitions
typedef PVOID (WINAPI *PSKIPLIST_ALLOCATE_ROUTINE)(DWORD);
typedef int (WINAPI *PSKIPLIST_COMPARE_ROUTINE)(PVOID, PVOID);
typedef void (WINAPI *PSKIPLIST_FREE_ROUTINE)(PVOID);
// Structure definitions
typedef struct _SKIPLIST_NODE
{
DWORD Distance[SKIPLIST_LEVELS];
struct _SKIPLIST_NODE* Next[SKIPLIST_LEVELS];
PVOID Element;
}
SKIPLIST_NODE, *PSKIPLIST_NODE;
typedef struct _SKIPLIST
{
SKIPLIST_NODE Head;
CHAR MaximumLevel;
DWORD NodeCount;
PSKIPLIST_ALLOCATE_ROUTINE AllocateRoutine;
PSKIPLIST_COMPARE_ROUTINE CompareRoutine;
PSKIPLIST_FREE_ROUTINE FreeRoutine;
}
SKIPLIST, *PSKIPLIST;
// Function prototypes
void InitializeSkiplist(PSKIPLIST Skiplist, PSKIPLIST_ALLOCATE_ROUTINE AllocateRoutine, PSKIPLIST_COMPARE_ROUTINE CompareRoutine, PSKIPLIST_FREE_ROUTINE FreeRoutine);
BOOL InsertElementSkiplist(PSKIPLIST Skiplist, PVOID Element);
BOOL InsertTailElementSkiplist(PSKIPLIST Skiplist, PVOID Element);
PVOID DeleteElementSkiplist(PSKIPLIST Skiplist, PVOID Element);
PVOID LookupElementSkiplist(PSKIPLIST Skiplist, PVOID Element, PDWORD ElementIndex);
[SKIPLIST] - Add a LookupNodeByIndexSkiplist function and a small test for it in skiplist_test. - Remove a redundant double-set in LookupElementSkiplist. Yes, we now have one lookup function that accepts search criteria and returns an element and another one that accepts an index and returns a SKIPLIST_NODE. It's simply because I have exactly these two cases :) You're free to implement the two missing functions or refactor this code another way. svn path=/branches/colins-printing-for-freedom/; revision=68262
2015-06-25 13:12:01 +00:00
PSKIPLIST_NODE LookupNodeByIndexSkiplist(PSKIPLIST Skiplist, DWORD ElementIndex);
[SKIPLIST] Add my implementation of an efficient Skiplist. A Skiplist can do insertion, deletion and lookups in O(log N) on average just like balanced trees. It features simpler algorithms though due to purely relying on probabilistic balancing at insertion and not on rebalancing with every modification. This simple structure allowed me to implement some additions on top of the standard algorithms: * Storing distances between elements on each level to efficiently return the index of the element in the Skiplist when doing a lookup. * InsertTailElementSkiplist to explicitly insert an element at the end of the Skiplist. This needs no comparisons and is useful when you can be sure that the new element would be inserted at the end (e.g. for a new print job in the queue with default priority). More features are easily possible, but for now I limited features on those needed for my Local Spooler work. Some references on Skiplists: * ftp://ftp.cs.umd.edu/pub/skipLists/skiplists.pdf * http://drum.lib.umd.edu/bitstream/1903/544/2/CS-TR-2286.1.pdf svn path=/branches/colins-printing-for-freedom/; revision=68191
2015-06-19 10:27:46 +00:00
#endif
Reference in a new issue Copy permalink