C# 使用文件流来读写ini文件
背景
之前采用ini文件作为程序的配置文件，觉得这种结构简单明了，配置起来也挺方便。然后操作方式是通过WindowsAPI，然后再网上找到一个基于WindowsAPI封装的help类，用起来倒也顺手。用的多了，觉得还可以使用文件流来操作，后来就发现了EasyConfig。
EasyConfig是一个纯C#的开源ini文件操作库，但是在使用上有诸多不便，只是个人感觉，于是个人将其改造了一下，是自己喜欢用的风格。
资源下载
如果不清楚ini文件结构，请百度一下，这里贴一个示例文件。
Ini文件示例
[Video]
#是否全屏
Fullscreen = true
#宽度
Width = 1280
#电视高度
#高度
Height = 720
[Level1]
NumberOfEnemies=2000#数值
Lives = 10
Timer = 999
EnemyNames = "Steve", "Sam", "Bill"
EnemyGuns = 13, 28, 43, 499
CanShoot = true, yes, on, no, false, off
Ini文件示例
代码示例
首先来看看改写后，怎么去使用她来读写Ini文件。
static void Main(string[] args)
{
ConfigFile configFile = new ConfigFile("Test.ini"); //遍历Config文件
foreach (var group in configFile.SettingGroups)
{
Console.WriteLine("****************************");
Console.WriteLine(group.Key + ":");
Console.WriteLine(); foreach (var value in group.Value.Settings)
Console.WriteLine("{0} = {1} (Is Array? {2}),{3}", value.Key, value.Value.RawValue, value.Value.IsArray, value.Value.Desp); Console.WriteLine();
}
//读取值主要是在具体的配置项上进行读取,是首先定位到[Group],其次就是具体的项
//使用泛型读取值，并指定读取失败时的默认值
var fullScreen = configFile["Video"]["Fullscreen"].As<int>(-1);//失败
var bFullScreen = configFile["Video"]["Fullscreen"].AsBool();//成功
var arrCanShoot = configFile["Level1"]["CanShoot"].AsArray<bool>();
//读取时 该项不存在,不存在的组或者项会自动添加
var noexists = configFile["Video"]["xxxxxxxxxxx"].AsString();
var noexists2 = configFile["Video111111111"]["xxxxxxxxxxx"].AsString(); //写入值有2种方法，可以直接向某组下写入一项,也可以定位到某组某项，写入值
//写入值 该项不存在，组或者项会自动创建
configFile["Video"].WriteSetting("NewName", "EasyConfig");
configFile["Video"].WriteSetting("NewName", "EasyConfig2.0");
configFile["Video22222222"].WriteSetting("c1", "1");
//索引器不过是返回Setting
configFile["Video3333"]["UserName"].SetValue("admin");
configFile["Viedo4444"]["Sex"].SetValue("男", "女", "保密");
//写入值，该项不存在
configFile["Video222"].WriteSetting("NewName", "EasyConfig3.0"); Console.ReadKey(true); configFile.Save("TestConfig2.txt");
}
基本上自己想要的效果，则是基于 ConfigFile["GroupName"]["Key"] 这样的方式来进行读写。
另外附上一个基于WindowsAPI操作的封装类。
/// <summary>
/// Provides methods for reading and writing to an INI file.
/// </summary>
public class IniFileHelp
{
/// <summary>
/// The maximum size of a section in an ini file.
/// </summary>
/// <remarks>
/// This property defines the maximum size of the buffers
/// used to retreive data from an ini file. This value is
/// the maximum allowed by the win32 functions
/// GetPrivateProfileSectionNames() or
/// GetPrivateProfileString().
/// </remarks>
public const int MaxSectionSize = 32767; // 32 KB
//The path of the file we are operating on.
private string m_path;
#region P/Invoke declares
/// <summary>
/// A static class that provides the win32 P/Invoke signatures
/// used by this class.
/// </summary>
/// <remarks>
/// Note: In each of the declarations below, we explicitly set CharSet to
/// Auto. By default in C#, CharSet is set to Ansi, which reduces
/// performance on windows 2000 and above due to needing to convert strings
/// from Unicode (the native format for all .Net strings) to Ansi before
/// marshalling. Using Auto lets the marshaller select the Unicode version of
/// these functions when available.
/// </remarks>
[System.Security.SuppressUnmanagedCodeSecurity]
private static class NativeMethods
{
[DllImport("kernel32.dll", CharSet = CharSet.Auto)]
public static extern int GetPrivateProfileSectionNames(IntPtr lpszReturnBuffer,
uint nSize,
string lpFileName);
[DllImport("kernel32.dll", CharSet = CharSet.Auto)]
public static extern uint GetPrivateProfileString(string lpAppName,
string lpKeyName,
string lpDefault,
StringBuilder lpReturnedString,
int nSize,
string lpFileName);
[DllImport("kernel32.dll", CharSet = CharSet.Auto)]
public static extern uint GetPrivateProfileString(string lpAppName,
string lpKeyName,
string lpDefault,
[In, Out] char[] lpReturnedString,
int nSize,
string lpFileName);
[DllImport("kernel32.dll", CharSet = CharSet.Auto)]
public static extern int GetPrivateProfileString(string lpAppName,
string lpKeyName,
string lpDefault,
IntPtr lpReturnedString,
uint nSize,
string lpFileName);
[DllImport("kernel32.dll", CharSet = CharSet.Auto)]
public static extern int GetPrivateProfileInt(string lpAppName,
string lpKeyName,
int lpDefault,
string lpFileName);
[DllImport("kernel32.dll", CharSet = CharSet.Auto)]
public static extern int GetPrivateProfileSection(string lpAppName,
IntPtr lpReturnedString,
uint nSize,
string lpFileName);
//We explicitly enable the SetLastError attribute here because
// WritePrivateProfileString returns errors via SetLastError.
// Failure to set this can result in errors being lost during
// the marshal back to managed code.
[DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
public static extern bool WritePrivateProfileString(string lpAppName,
string lpKeyName,
string lpString,
string lpFileName);
}
#endregion
/// <summary>
/// Initializes a new instance of the <see cref="IniFileHelp"/> class.
/// </summary>
/// <param name="path">The ini file to read and write from.</param>
public IniFileHelp(string path)
{
//Convert to the full path. Because of backward compatibility,
// the win32 functions tend to assume the path should be the
// root Windows directory if it is not specified. By calling
// GetFullPath, we make sure we are always passing the full path
// the win32 functions.
m_path = System.IO.Path.GetFullPath(path);
}
/// <summary>
/// Gets the full path of ini file this object instance is operating on.
/// </summary>
/// <value>A file path.</value>
public string Path
{
get
{
return m_path;
}
}
#region Get Value Methods
/// <summary>
/// Gets the value of a setting in an ini file as a <see cref="T:System.String"/>.
/// </summary>
/// <param name="sectionName">The name of the section to read from.</param>
/// <param name="keyName">The name of the key in section to read.</param>
/// <param name="defaultValue">The default value to return if the key
/// cannot be found.</param>
/// <returns>The value of the key, if found. Otherwise, returns
/// <paramref name="defaultValue"/></returns>
/// <remarks>
/// The retreived value must be less than 32KB in length.
/// </remarks>
/// <exception cref="ArgumentNullException">
/// <paramref name="sectionName"/> or <paramref name="keyName"/> are
/// a null reference (Nothing in VB)
/// </exception>
public string GetString(string sectionName,
string keyName,
string defaultValue)
{
if (sectionName == null)
throw new ArgumentNullException("sectionName");
if (keyName == null)
throw new ArgumentNullException("keyName");
StringBuilder retval = new StringBuilder(IniFileHelp.MaxSectionSize);
NativeMethods.GetPrivateProfileString(sectionName,
keyName,
defaultValue,
retval,
IniFileHelp.MaxSectionSize,
m_path);
return retval.ToString();
}
/// <summary>
/// Gets the value of a setting in an ini file as a <see cref="T:System.Int16"/>.
/// </summary>
/// <param name="sectionName">The name of the section to read from.</param>
/// <param name="keyName">The name of the key in section to read.</param>
/// <param name="defaultValue">The default value to return if the key
/// cannot be found.</param>
/// <returns>The value of the key, if found. Otherwise, returns
/// <paramref name="defaultValue"/>.</returns>
/// <exception cref="ArgumentNullException">
/// <paramref name="sectionName"/> or <paramref name="keyName"/> are
/// a null reference (Nothing in VB)
/// </exception>
public int GetInt16(string sectionName,
string keyName,
short defaultValue)
{
int retval = GetInt32(sectionName, keyName, defaultValue);
return Convert.ToInt16(retval);
}
/// <summary>
/// Gets the value of a setting in an ini file as a <see cref="T:System.Int32"/>.
/// </summary>
/// <param name="sectionName">The name of the section to read from.</param>
/// <param name="keyName">The name of the key in section to read.</param>
/// <param name="defaultValue">The default value to return if the key
/// cannot be found.</param>
/// <returns>The value of the key, if found. Otherwise, returns
/// <paramref name="defaultValue"/></returns>
/// <exception cref="ArgumentNullException">
/// <paramref name="sectionName"/> or <paramref name="keyName"/> are
/// a null reference (Nothing in VB)
/// </exception>
public int GetInt32(string sectionName,
string keyName,
int defaultValue)
{
if (sectionName == null)
throw new ArgumentNullException("sectionName");
if (keyName == null)
throw new ArgumentNullException("keyName");
return NativeMethods.GetPrivateProfileInt(sectionName, keyName, defaultValue, m_path);
}
/// <summary>
/// Gets the value of a setting in an ini file as a <see cref="T:System.Double"/>.
/// </summary>
/// <param name="sectionName">The name of the section to read from.</param>
/// <param name="keyName">The name of the key in section to read.</param>
/// <param name="defaultValue">The default value to return if the key
/// cannot be found.</param>
/// <returns>The value of the key, if found. Otherwise, returns
/// <paramref name="defaultValue"/></returns>
/// <exception cref="ArgumentNullException">
/// <paramref name="sectionName"/> or <paramref name="keyName"/> are
/// a null reference (Nothing in VB)
/// </exception>
public double GetDouble(string sectionName,
string keyName,
double defaultValue)
{
string retval = GetString(sectionName, keyName, "");
if (retval == null || retval.Length == 0)
{
return defaultValue;
}
return Convert.ToDouble(retval, CultureInfo.InvariantCulture);
}
#endregion
#region GetSectionValues Methods
/// <summary>
/// Gets all of the values in a section as a list.
/// </summary>
/// <param name="sectionName">
/// Name of the section to retrieve values from.
/// </param>
/// <returns>
/// A <see cref="List{T}"/> containing <see cref="KeyValuePair{T1, T2}"/> objects
/// that describe this section. Use this verison if a section may contain
/// multiple items with the same key value. If you know that a section
/// cannot contain multiple values with the same key name or you don't
/// care about the duplicates, use the more convenient
/// <see cref="GetSectionValues"/> function.
/// </returns>
/// <exception cref="ArgumentNullException">
/// <paramref name="sectionName"/> is a null reference (Nothing in VB)
/// </exception>
public List<KeyValuePair<string, string>> GetSectionValuesAsList(string sectionName)
{
List<KeyValuePair<string, string>> retval;
string[] keyValuePairs;
string key, value;
int equalSignPos;
if (sectionName == null)
throw new ArgumentNullException("sectionName");
//Allocate a buffer for the returned section names.
IntPtr ptr = Marshal.AllocCoTaskMem(IniFileHelp.MaxSectionSize);
try
{
//Get the section key/value pairs into the buffer.
int len = NativeMethods.GetPrivateProfileSection(sectionName,
ptr,
IniFileHelp.MaxSectionSize,
m_path);
keyValuePairs = ConvertNullSeperatedStringToStringArray(ptr, len);
}
finally
{
//Free the buffer
Marshal.FreeCoTaskMem(ptr);
}
//Parse keyValue pairs and add them to the list.
retval = new List<KeyValuePair<string, string>>(keyValuePairs.Length);
for (int i = 0; i < keyValuePairs.Length; ++i)
{
//Parse the "key=value" string into its constituent parts
//Cancel a string start with '#'
var item = keyValuePairs[i].Trim();
if (item.Length > 0 && !item.StartsWith("#"))
{
equalSignPos = keyValuePairs[i].IndexOf('=');
key = keyValuePairs[i].Substring(0, equalSignPos);
value = keyValuePairs[i].Substring(equalSignPos + 1,
keyValuePairs[i].Length - equalSignPos - 1);
retval.Add(new KeyValuePair<string, string>(key, value));
}
}
return retval;
}
/// <summary>
/// Gets all of the values in a section as a dictionary.
/// </summary>
/// <param name="sectionName">
/// Name of the section to retrieve values from.
/// </param>
/// <returns>
/// A <see cref="Dictionary{T, T}"/> containing the key/value
/// pairs found in this section.
/// </returns>
/// <remarks>
/// If a section contains more than one key with the same name,
/// this function only returns the first instance. If you need to
/// get all key/value pairs within a section even when keys have the
/// same name, use <see cref="GetSectionValuesAsList"/>.
/// </remarks>
/// <exception cref="ArgumentNullException">
/// <paramref name="sectionName"/> is a null reference (Nothing in VB)
/// </exception>
public Dictionary<string, string> GetSectionValues(string sectionName)
{
List<KeyValuePair<string, string>> keyValuePairs;
Dictionary<string, string> retval;
keyValuePairs = GetSectionValuesAsList(sectionName);
//Convert list into a dictionary.
retval = new Dictionary<string, string>(keyValuePairs.Count);
foreach (KeyValuePair<string, string> keyValuePair in keyValuePairs)
{
//Skip any key we have already seen.
if (!retval.ContainsKey(keyValuePair.Key))
{
retval.Add(keyValuePair.Key, keyValuePair.Value);
}
}
return retval;
}
#endregion
#region Get Key/Section Names
/// <summary>
/// Gets the names of all keys under a specific section in the ini file.
/// </summary>
/// <param name="sectionName">
/// The name of the section to read key names from.
/// </param>
/// <returns>An array of key names.</returns>
/// <remarks>
/// The total length of all key names in the section must be
/// less than 32KB in length.
/// </remarks>
/// <exception cref="ArgumentNullException">
/// <paramref name="sectionName"/> is a null reference (Nothing in VB)
/// </exception>
public string[] GetKeyNames(string sectionName)
{
int len;
string[] retval;
if (sectionName == null)
throw new ArgumentNullException("sectionName");
//Allocate a buffer for the returned section names.
IntPtr ptr = Marshal.AllocCoTaskMem(IniFileHelp.MaxSectionSize);
try
{
//Get the section names into the buffer.
len = NativeMethods.GetPrivateProfileString(sectionName,
null,
null,
ptr,
IniFileHelp.MaxSectionSize,
m_path);
retval = ConvertNullSeperatedStringToStringArray(ptr, len);
}
finally
{
//Free the buffer
Marshal.FreeCoTaskMem(ptr);
}
return retval;
}
/// <summary>
/// Gets the names of all sections in the ini file.
/// </summary>
/// <returns>An array of section names.</returns>
/// <remarks>
/// The total length of all section names in the section must be
/// less than 32KB in length.
/// </remarks>
public string[] GetSectionNames()
{
string[] retval;
int len;
//Allocate a buffer for the returned section names.
IntPtr ptr = Marshal.AllocCoTaskMem(IniFileHelp.MaxSectionSize);
try
{
//Get the section names into the buffer.
len = NativeMethods.GetPrivateProfileSectionNames(ptr,
IniFileHelp.MaxSectionSize, m_path);
retval = ConvertNullSeperatedStringToStringArray(ptr, len);
}
finally
{
//Free the buffer
Marshal.FreeCoTaskMem(ptr);
}
return retval;
}
/// <summary>
/// Converts the null seperated pointer to a string into a string array.
/// </summary>
/// <param name="ptr">A pointer to string data.</param>
/// <param name="valLength">
/// Length of the data pointed to by <paramref name="ptr"/>.
/// </param>
/// <returns>
/// An array of strings; one for each null found in the array of characters pointed
/// at by <paramref name="ptr"/>.
/// </returns>
private static string[] ConvertNullSeperatedStringToStringArray(IntPtr ptr, int valLength)
{
string[] retval;
if (valLength == 0)
{
//Return an empty array.
retval = new string[0];
}
else
{
//Convert the buffer into a string. Decrease the length
//by 1 so that we remove the second null off the end.
string buff = Marshal.PtrToStringAuto(ptr, valLength - 1);
//Parse the buffer into an array of strings by searching for nulls.
retval = buff.Split('\0');
}
return retval;
}
#endregion
#region Write Methods
/// <summary>
/// Writes a <see cref="T:System.String"/> value to the ini file.
/// </summary>
/// <param name="sectionName">The name of the section to write to .</param>
/// <param name="keyName">The name of the key to write to.</param>
/// <param name="value">The string value to write</param>
/// <exception cref="T:System.ComponentModel.Win32Exception">
/// The write failed.
/// </exception>
private void WriteValueInternal(string sectionName, string keyName, string value)
{
if (!NativeMethods.WritePrivateProfileString(sectionName, keyName, value, m_path))
{
throw new System.ComponentModel.Win32Exception();
}
}
/// <summary>
/// Writes a <see cref="T:System.String"/> value to the ini file.
/// </summary>
/// <param name="sectionName">The name of the section to write to .</param>
/// <param name="keyName">The name of the key to write to.</param>
/// <param name="value">The string value to write</param>
/// <exception cref="T:System.ComponentModel.Win32Exception">
/// The write failed.
/// </exception>
/// <exception cref="ArgumentNullException">
/// <paramref name="sectionName"/> or <paramref name="keyName"/> or
/// <paramref name="value"/> are a null reference (Nothing in VB)
/// </exception>
public void WriteValue(string sectionName, string keyName, string value)
{
if (sectionName == null)
throw new ArgumentNullException("sectionName");
if (keyName == null)
throw new ArgumentNullException("keyName");
if (value == null)
throw new ArgumentNullException("value");
WriteValueInternal(sectionName, keyName, value);
}
/// <summary>
/// Writes an <see cref="T:System.Int16"/> value to the ini file.
/// </summary>
/// <param name="sectionName">The name of the section to write to .</param>
/// <param name="keyName">The name of the key to write to.</param>
/// <param name="value">The value to write</param>
/// <exception cref="T:System.ComponentModel.Win32Exception">
/// The write failed.
/// </exception>
public void WriteValue(string sectionName, string keyName, short value)
{
WriteValue(sectionName, keyName, (int)value);
}
/// <summary>
/// Writes an <see cref="T:System.Int32"/> value to the ini file.
/// </summary>
/// <param name="sectionName">The name of the section to write to .</param>
/// <param name="keyName">The name of the key to write to.</param>
/// <param name="value">The value to write</param>
/// <exception cref="T:System.ComponentModel.Win32Exception">
/// The write failed.
/// </exception>
/// <exception cref="ArgumentNullException">
/// <paramref name="sectionName"/> or <paramref name="keyName"/> are
/// a null reference (Nothing in VB)
/// </exception>
public void WriteValue(string sectionName, string keyName, int value)
{
WriteValue(sectionName, keyName, value.ToString(CultureInfo.InvariantCulture));
}
/// <summary>
/// Writes an <see cref="T:System.Single"/> value to the ini file.
/// </summary>
/// <param name="sectionName">The name of the section to write to .</param>
/// <param name="keyName">The name of the key to write to.</param>
/// <param name="value">The value to write</param>
/// <exception cref="T:System.ComponentModel.Win32Exception">
/// The write failed.
/// </exception>
/// <exception cref="ArgumentNullException">
/// <paramref name="sectionName"/> or <paramref name="keyName"/> are
/// a null reference (Nothing in VB)
/// </exception>
public void WriteValue(string sectionName, string keyName, float value)
{
WriteValue(sectionName, keyName, value.ToString(CultureInfo.InvariantCulture));
}
/// <summary>
/// Writes an <see cref="T:System.Double"/> value to the ini file.
/// </summary>
/// <param name="sectionName">The name of the section to write to .</param>
/// <param name="keyName">The name of the key to write to.</param>
/// <param name="value">The value to write</param>
/// <exception cref="T:System.ComponentModel.Win32Exception">
/// The write failed.
/// </exception>
/// <exception cref="ArgumentNullException">
/// <paramref name="sectionName"/> or <paramref name="keyName"/> are
/// a null reference (Nothing in VB)
/// </exception>
public void WriteValue(string sectionName, string keyName, double value)
{
WriteValue(sectionName, keyName, value.ToString(CultureInfo.InvariantCulture));
}
#endregion
#region Delete Methods
/// <summary>
/// Deletes the specified key from the specified section.
/// </summary>
/// <param name="sectionName">
/// Name of the section to remove the key from.
/// </param>
/// <param name="keyName">
/// Name of the key to remove.
/// </param>
/// <exception cref="ArgumentNullException">
/// <paramref name="sectionName"/> or <paramref name="keyName"/> are
/// a null reference (Nothing in VB)
/// </exception>
public void DeleteKey(string sectionName, string keyName)
{
if (sectionName == null)
throw new ArgumentNullException("sectionName");
if (keyName == null)
throw new ArgumentNullException("keyName");
WriteValueInternal(sectionName, keyName, null);
}
/// <summary>
/// Deletes a section from the ini file.
/// </summary>
/// <param name="sectionName">
/// Name of the section to delete.
/// </param>
/// <exception cref="ArgumentNullException">
/// <paramref name="sectionName"/> is a null reference (Nothing in VB)
/// </exception>
public void DeleteSection(string sectionName)
{
if (sectionName == null)
throw new ArgumentNullException("sectionName");
WriteValueInternal(sectionName, null, null);
}
#endregion
}
IniFileHelp
MSD_radix_sort
一、这次是在上一次尝试基础上进行的，预期是达到上次性能的9倍。
MSD的基本手法就是不断切片。
每一步都是把整体数据切割成256片，如上图所示，实际情况切片未必均匀，有的slice内可能一个元素也没有。
接下来对于每个切片怎么办呢？
答案是继续切，对于特殊数据来讲，切片过程可以很快结束，这样就可以实现比LSD更快的速度。
这里面最困难的地方就是如何存储每个slice的头和尾。
如果采用下述方式，应该是行不通的。
这个方式需要做数组元素插入，还要跟踪中间数据，因此没具体考虑。
我真正采用的是下表：
表中第一项表示第一个元素开启一个类别，紧跟的0表示此元素和上面的1是同一类。
至于2表明在切片过程中是一个孤立的元素，后续就没必要再切片了。
这个方式可以大大简化编码。
二、伪代码。
for each slice
if slice-tag == 2 continue;
if slice-tag == 1
slice it;
update bookkeeping
int main(){
HANDLE heap = NULL;
Bucket bucket[BUCKETSLOTCOUNT];
PageList * pageListPool;
int plpAvailable = 0;
int * pages = NULL;
int * pagesAvailable = NULL;
int * objIdx;
unsigned short * s;
__int8 * classifier = NULL;
time_t timeBegin;
time_t timeEnd;
heap = HeapCreate(HEAP_NO_SERIALIZE|HEAP_GENERATE_EXCEPTIONS, 1024*1024, 0);
if (heap != NULL){
pages = (int * )HeapAlloc(heap, 0, (TFSI/PAGEGRANULAR + BUCKETSLOTCOUNT + 8) * PAGEAMOUNT);
pageListPool = (PageList *)HeapAlloc(heap, 0, (TFSI/PAGEGRANULAR + 8) * sizeof(PageList));
s = (unsigned short *)HeapAlloc(heap, 0, TFSI*sizeof(unsigned short));
objIdx = (int *)HeapAlloc(heap, 0, TFSI * sizeof(int));
classifier = (__int8 *)HeapAlloc(heap, 0, (TFSI+8)*sizeof(__int8));
}
MakeSure(pages != NULL && pageListPool != NULL && objIdx != NULL && classifier != NULL);
for(int i=0; i<TFSI; i++) objIdx[i]=i;
timeBegin = clock();
for (int i=0; i<TFSI; i++) s[i] = rand();
timeEnd = clock();
printf("\n%f(s) consumed in generating numbers", (double)(timeEnd-timeBegin)/CLOCKS_PER_SEC);
SecureZeroMemory(classifier, TFSI*sizeof(__int8));
classifier[0] = 1;
classifier[TFSI] = 1;
timeBegin = clock();
bool no_need_further_processing = false;
for (int t=sizeof(short)-1; t>=0; t--){
int bucketIdx;
int slice_pointer = 0;
int slice_base = 0;
int flagCounter = 0;
if (no_need_further_processing) break;
//classifier: 1 new catagory
//classifier: 2 completed catagory process
while (slice_pointer < TFSI){
if (classifier[slice_pointer] == 2){
slice_base = slice_pointer;
classifier[slice_base] = 0;
while (classifier[slice_pointer] == 0){
slice_pointer++;
flagCounter++;
}
classifier[slice_base] = 2;
if (flagCounter == TFSI) no_need_further_processing = true;
continue;
}
if (classifier[slice_pointer] == 1){
FillMemory(pages, (TFSI/PAGEGRANULAR + BUCKETSLOTCOUNT + 8) * PAGEAMOUNT, 0xff);
SecureZeroMemory(pageListPool, (TFSI/PAGEGRANULAR + 8) * sizeof(PageList));
pagesAvailable = pages;
plpAvailable = 0;
for(int i=0; i<256; i++){
bucket[i].currentPagePtr = pagesAvailable;
bucket[i].offset = 0;
bucket[i].pl.PagePtr = pagesAvailable;
bucket[i].pl.next = NULL;
pagesAvailable += PAGEGRANULAR;
bucket[i].currentPageListItem = &(bucket[i].pl);
}
slice_base = slice_pointer;
classifier[slice_base] = 0;
while (classifier[slice_pointer] == 0){
//for each slice element, push_back to pages;
unsigned char * cell = (unsigned char *)&s[objIdx[slice_pointer]];
bucketIdx = cell[t];
//save(bucketIdx, objIdx[i]);
bucket[bucketIdx].currentPagePtr[ bucket[bucketIdx].offset ] = objIdx[slice_pointer];
bucket[bucketIdx].offset++;
if (bucket[bucketIdx].offset == PAGEGRANULAR){
bucket[bucketIdx].currentPageListItem->next = &pageListPool[plpAvailable];
plpAvailable++;
bucket[bucketIdx].currentPageListItem->next->PagePtr = pagesAvailable;
bucket[bucketIdx].currentPageListItem->next->next = NULL;
bucket[bucketIdx].currentPagePtr = pagesAvailable;
bucket[bucketIdx].offset = 0;
pagesAvailable += PAGEGRANULAR;
bucket[bucketIdx].currentPageListItem = bucket[bucketIdx].currentPageListItem->next;
}
slice_pointer++;
}
classifier[slice_base] = 1;
//update classifier;
//update objIdx index
int start = slice_base;
for (int i=0; i<256; i++){
PageList * p;
p = &(bucket[i].pl);
//classifier: 1 new catagory
//classifier: 2 complete catagory process
classifier[start] = 1;
int counters = 0;
while (p){
for (int t=0; t<PAGEGRANULAR; t++){
int idx = p->PagePtr[t];
if (idx != TERMINATOR){
objIdx[start] = idx;
start++;
counters++;
}
if (idx == TERMINATOR) break;
}
p = p->next;
}
if (counters == 1) classifier[start-1] = 2;
}
//update objIdx index
} //if (classifier[slice_pointer] == 1)
} //while (slice_pointer < TFSI)
} //for (int t=sizeof(short)-1; t>=0; t--)
timeEnd = clock();
printf("\n%f(s) consumed in generating results", (double)(timeEnd-timeBegin)/CLOCKS_PER_SEC);
//for(int i=0; i<TFSI; i++) printf("%d\n", s[objIdx[i]]);
HeapFree(heap, 0, pages);
HeapFree(heap, 0, pageListPool);
HeapFree(heap, 0, s);
HeapFree(heap, 0, objIdx);
HeapFree(heap, 0, classifier);
HeapDestroy(heap);
return 0;
}
三、测试
1024*1024*100 个短整型。
时间 5.438s
看到这里就知道杯具了，比LSD还慢。
如果应用到二维表，会更惨不忍睹。试了下果然如此。
四、讨论
如果哪位有更好的方法，欢迎讨论。
或者，基数排序只是一个花瓶？