text:
// Copyright (c) Tunnel Vision Laboratories, LLC. All rights reserved.
// Licensed under the MIT license. See LICENSE file in the project root for full license information.

#pragma warning disable IDE1006 // Naming Styles

namespace NOpenCL
{
    using System;
    using System.Runtime.InteropServices;

    /// <content>
    /// Devices.
    /// </content>
    internal partial class UnsafeNativeMethods
    {
        [DllImport(ExternDll.OpenCL)]
        private static extern ErrorCode clGetDeviceIDs(
            ClPlatformID platform,
            DeviceType deviceType,
            uint numEntries,
            [Out, MarshalAs(UnmanagedType.LPArray)] ClDeviceID[] devices,
            out uint numDevices);

        public static ClDeviceID[] GetDeviceIDs(ClPlatformID platform, DeviceType deviceType)
        {
            uint required;
            ErrorCode result = clGetDeviceIDs(platform, deviceType, 0, null, out required);
            if (result == ErrorCode.DeviceNotFound && required == 0)
                return new ClDeviceID[0];

            ErrorHandler.ThrowOnFailure(result);

            ClDeviceID[] devices = new ClDeviceID[required];
            uint actual;
            ErrorHandler.ThrowOnFailure(clGetDeviceIDs(platform, deviceType, required, devices, out actual));
            Array.Resize(ref devices, (int)actual);
            return devices;
        }

        [DllImport(ExternDll.OpenCL)]
        private static extern ErrorCode clGetDeviceInfo(
            ClDeviceID device,
            int paramName,
            UIntPtr paramValueSize,
            IntPtr paramValue,
            out UIntPtr paramValueSizeRet);

        public static T GetDeviceInfo<T>(ClDeviceID device, DeviceParameterInfo<T> parameter)
        {
            int? fixedSize = parameter.ParameterInfo.FixedSize;
#if DEBUG
            bool verifyFixedSize = true;
#else
            bool verifyFixedSize = false;
#endif

            UIntPtr requiredSize;
            if (fixedSize.HasValue && !verifyFixedSize)
                requiredSize = (UIntPtr)fixedSize;
            else
                ErrorHandler.ThrowOnFailure(clGetDeviceInfo(device, parameter.ParameterInfo.Name, UIntPtr.Zero, IntPtr.Zero, out requiredSize));

            if (verifyFixedSize && fixedSize.HasValue)
            {
                if (requiredSize.ToUInt64() != (ulong)fixedSize.Value)
                    throw new ArgumentException("The parameter definition includes a fixed size that does not match the required size according to the runtime.");
            }

            IntPtr memory = IntPtr.Zero;
            try
            {
                memory = Marshal.AllocHGlobal((int)requiredSize.ToUInt32());
                UIntPtr actualSize;
                ErrorHandler.ThrowOnFailure(clGetDeviceInfo(device, parameter.ParameterInfo.Name, requiredSize, memory, out actualSize));
                return parameter.ParameterInfo.Deserialize(actualSize, memory);
            }
            finally
            {
                Marshal.FreeHGlobal(memory);
            }
        }

        [StructLayout(LayoutKind.Sequential)]
        public struct ClDeviceID
        {
            private readonly IntPtr _handle;

            public IntPtr Handle
            {
                get
                {
                    return _handle;
                }
            }
        }

        public static class DeviceInfo
        {
            /// <summary>
            /// The default compute device address space size specified as an unsigned integer
            /// value in bits. Currently supported values are 32 or 64 bits.
            /// </summary>
            public static readonly DeviceParameterInfo<uint> AddressBits = (DeviceParameterInfo<uint>)new ParameterInfoUInt32(0x100D);

            /// <summary>
            /// Is true if the device is available and false if the device is not available.
            /// </summary>
            public static readonly DeviceParameterInfo<bool> Available = (DeviceParameterInfo<bool>)new ParameterInfoBoolean(0x1027);

            /// <summary>
            /// A semi-colon separated list of built-in kernels supported by the device. An
            /// empty string is returned if no built-in kernels are supported by the device.
            /// </summary>
            public static readonly DeviceParameterInfo<string> BuiltInKernels = (DeviceParameterInfo<string>)new ParameterInfoString(0x103F);

            /// <summary>
            /// Is false if the implementation does not have a compiler available to compile
            /// the program source. Is true if the compiler is available. This can be false
            /// for the embedded platform profile only.
            /// </summary>
            public static readonly DeviceParameterInfo<bool> CompilerAvailable = (DeviceParameterInfo<bool>)new ParameterInfoBoolean(0x1028);

            /// <summary>
            /// Describes double precision floating-point capability of the OpenCL device.
            /// This is a bit-field that describes one or more of the following values:
            ///
            /// <list type="bullet">
            /// <item><see cref="FloatingPointConfiguration.Denorm"/> - denorms are supported.</item>
            /// <item><see cref="FloatingPointConfiguration.InfNaN"/> - INF and NaNs are supported.</item>
            /// <item><see cref="FloatingPointConfiguration.RoundToNearest"/> - round to nearest even rounding mode supported.</item>
            /// <item><see cref="FloatingPointConfiguration.RoundToZero"/> - round to zero rounding mode supported.</item>
            /// <item><see cref="FloatingPointConfiguration.RoundToInf"/> - round to positive and negative infinity rounding modes supported.</item>
            /// <item><see cref="FloatingPointConfiguration.Fma"/> - IEEE754-2008 fused multiply-add is supported.</item>
            /// <item><see cref="FloatingPointConfiguration.SoftFloat"/> - Basic floating-point operations (such as addition, subtraction, multiplication) are implemented in software.</item>
            /// </list>
            /// <para/>
            /// Double precision is an optional feature so the mandated minimum double
            /// precision floating-point capability is 0.
            /// <para/>
            /// If double precision is supported by the device, then the minimum double
            /// precision floatingpoint capability must be:
            /// <c><see cref="FloatingPointConfiguration.Fma"/> | <see cref="FloatingPointConfiguration.RoundToNearest"/> | <see cref="FloatingPointConfiguration.RoundToZero"/> | <see cref="FloatingPointConfiguration.RoundToInf"/> | <see cref="FloatingPointConfiguration.InfNaN"/> | <see cref="FloatingPointConfiguration.Denorm"/></c>
            /// .
            /// </summary>
            public static readonly DeviceParameterInfo<ulong> DoubleFloatingPointConfiguration = (DeviceParameterInfo<ulong>)new ParameterInfoUInt64(0x1032);

            /// <summary>
            /// Is true if the OpenCL device is a little endian device and false otherwise.
            /// </summary>
            public static readonly DeviceParameterInfo<bool> LittleEndian = (DeviceParameterInfo<bool>)new ParameterInfoBoolean(0x1026);

            /// <summary>
            /// Is true if the device implements error correction for all accesses to compute
            /// device memory (global and constant). Is false if the device does not implement
            /// such error correction.
            /// </summary>
            public static readonly DeviceParameterInfo<bool> ErrorCorrectionSupport = (DeviceParameterInfo<bool>)new ParameterInfoBoolean(0x1024);

            /// <summary>
            /// Describes the execution capabilities of the device. This is a bit-field that
            /// describes one or more of the following values:
            ///
            /// <list type="bullet">
            /// <item><see cref="NOpenCL.ExecutionCapabilities.Kernel"/> - The OpenCL device can execute OpenCL kernels.</item>
            /// <item><see cref="NOpenCL.ExecutionCapabilities.NativeKernel"/> - The OpenCL device can execute native kernels.</item>
            /// </list>
            ///
            /// The mandated minimum capability is <see cref="NOpenCL.ExecutionCapabilities.Kernel"/>.
            /// </summary>
            public static readonly DeviceParameterInfo<ulong> ExecutionCapabilities = (DeviceParameterInfo<ulong>)new ParameterInfoUInt64(0x1029);

            /// <summary>
            /// Returns a space separated list of extension names (the extension names
            /// themselves do not contain any spaces) supported by the device. The list
            /// of extension names returned can be vendor supported extension names and
            /// one or more of the following Khronos approved extension names:
            ///
            /// <list type="bullet">
            /// <item>cl_khr_int64_base_atomics</item>
            /// <item>cl_khr_int64_extended_atomics</item>
            /// <item>cl_khr_fp16</item>
            /// <item>cl_khr_gl_sharing</item>
            /// <item>cl_khr_gl_event</item>
            /// <item>cl_khr_d3d10_sharing</item>
            /// <item>cl_khr_dx9_media_sharing</item>
            /// <item>cl_khr_d3d11_sharing</item>
            /// </list>
            /// </summary>
            public static readonly DeviceParameterInfo<string> Extensions = (DeviceParameterInfo<string>)new ParameterInfoString(0x1030);

            /// <summary>
            /// Size of global memory cache in bytes.
            /// </summary>
            public static readonly DeviceParameterInfo<ulong> GlobalCacheSize = (DeviceParameterInfo<ulong>)new ParameterInfoUInt64(0x101E);

            /// <summary>
            /// Type of global memory cache supported. Valid values are:
            /// <see cref="CacheType.None"/>, <see cref="CacheType.ReadOnly"/>,
            /// and <see cref="CacheType.ReadWrite"/>.
            /// </summary>
            public static readonly DeviceParameterInfo<uint> GlobalCacheType = (DeviceParameterInfo<uint>)new ParameterInfoUInt32(0x101C);

            /// <summary>
            /// Size of global memory cache line in bytes.
            /// </summary>
            public static readonly DeviceParameterInfo<uint> GlobalCacheLineSize = (DeviceParameterInfo<uint>)new ParameterInfoUInt32(0x101D);

            /// <summary>
            /// Size of global device memory in bytes.
            /// </summary>
            public static readonly DeviceParameterInfo<ulong> GlobalMemorySize = (DeviceParameterInfo<ulong>)new ParameterInfoUInt64(0x101F);

            /// <summary>
            /// Describes the OPTIONAL half precision floating-point capability of the
            /// OpenCL device. This is a bit-field that describes one or more of the
            /// following values:
            ///
            /// <list type="bullet">
            /// <item><see cref="FloatingPointConfiguration.Denorm"/> - denorms are supported.</item>
            /// <item><see cref="FloatingPointConfiguration.InfNaN"/> - INF and NaNs are supported.</item>
            /// <item><see cref="FloatingPointConfiguration.RoundToNearest"/> - round to nearest even rounding mode supported.</item>
            /// <item><see cref="FloatingPointConfiguration.RoundToZero"/> - round to zero rounding mode supported.</item>
            /// <item><see cref="FloatingPointConfiguration.RoundToInf"/> - round to +ve and -ve infinity rounding modes supported.</item>
            /// <item><see cref="FloatingPointConfiguration.Fma"/> - IEEE754-2008 fused multiply-add is supported.</item>
            /// <item><see cref="FloatingPointConfiguration.SoftFloat"/> - Basic floating-point operations (such as addition, subtraction, multiplication) are implemented in software.</item>
            /// </list>
            /// <para/>
            /// The required minimum half precision floating-point capability as implemented by this extension is
            /// <c><see cref="FloatingPointConfiguration.RoundToZero"/></c> or <c><see cref="FloatingPointConfiguration.RoundToInf"/> | <see cref="FloatingPointConfiguration.InfNaN"/></c>
            /// .
            /// </summary>
            public static readonly DeviceParameterInfo<ulong> HalfFloatingPointConfiguration = (DeviceParameterInfo<ulong>)new ParameterInfoUInt64(0x1033);

            /// <summary>
            /// Is true if the device and the host have a unified memory subsystem and is false otherwise.
            /// </summary>
            public static readonly DeviceParameterInfo<bool> HostUnifiedMemory = (DeviceParameterInfo<bool>)new ParameterInfoBoolean(0x1035);

            /// <summary>
            /// Is true if images are supported by the OpenCL device and false otherwise.
            /// </summary>
            public static readonly DeviceParameterInfo<bool> ImageSupport = (DeviceParameterInfo<bool>)new ParameterInfoBoolean(0x1016);

            /// <summary>
            /// Max height of 2D image in pixels. The minimum value is 8192 if <see cref="ImageSupport"/> is true.
            /// </summary>
            public static readonly DeviceParameterInfo<UIntPtr> Image2DMaxHeight = (DeviceParameterInfo<UIntPtr>)new ParameterInfoUIntPtr(0x1012);

            /// <summary>
            /// Max width of 2D image or 1D image not created from a buffer object in pixels. The minimum value is 8192 if <see cref="ImageSupport"/> is true.
            /// </summary>
            public static readonly DeviceParameterInfo<UIntPtr> Image2DMaxWidth = (DeviceParameterInfo<UIntPtr>)new ParameterInfoUIntPtr(0x1011);

            /// <summary>
            /// Max depth of 3D image in pixels. The minimum value is 2048 if <see cref="ImageSupport"/> is true.
            /// </summary>
            public static readonly DeviceParameterInfo<UIntPtr> Image3DMaxDepth = (DeviceParameterInfo<UIntPtr>)new ParameterInfoUIntPtr(0x1015);

            /// <summary>
            /// Max height of 3D image in pixels. The minimum value is 2048 if <see cref="ImageSupport"/> is true.
            /// </summary>
            public static readonly DeviceParameterInfo<UIntPtr> Image3DMaxHeight = (DeviceParameterInfo<UIntPtr>)new ParameterInfoUIntPtr(0x1014);

            /// <summary>
            /// Max width of 3D image in pixels. The minimum value is 2048 if <see cref="ImageSupport"/> is true.
            /// </summary>
            public static readonly DeviceParameterInfo<UIntPtr> Image3DMaxWidth = (DeviceParameterInfo<UIntPtr>)new ParameterInfoUIntPtr(0x1013);

            /// <summary>
            /// Max number of pixels for a 1D image created from a buffer object. The minimum value is 65536 if <see cref="ImageSupport"/> is true.
            /// </summary>
            public static readonly DeviceParameterInfo<UIntPtr> ImageMaxBufferSize = (DeviceParameterInfo<UIntPtr>)new ParameterInfoUIntPtr(0x1040);

            /// <summary>
            /// Max number of images in a 1D or 2D image array. The minimum value is 2048 if <see cref="ImageSupport"/> is true.
            /// </summary>
            public static readonly DeviceParameterInfo<UIntPtr> ImageMaxArraySize = (DeviceParameterInfo<UIntPtr>)new ParameterInfoUIntPtr(0x1041);

            /// <summary>
            /// Is false if the implementation does not have a linker available. Is true
            /// if the linker is available. This can be false for the embedded platform
            /// profile only. This must be true if <see cref="CompilerAvailable"/> is true.
            /// </summary>
            public static readonly DeviceParameterInfo<bool> LinkerAvailable = (DeviceParameterInfo<bool>)new ParameterInfoBoolean(0x103E);

            /// <summary>
            /// Size of local memory arena in bytes. The minimum value is 32 KB for devices
            /// that are not of type <see cref="NOpenCL.DeviceType.Custom"/>.
            /// </summary>
            public static readonly DeviceParameterInfo<ulong> LocalMemorySize = (DeviceParameterInfo<ulong>)new ParameterInfoUInt64(0x1023);

            /// <summary>
            /// Type of local memory supported. This can be set to <see cref="NOpenCL.LocalMemoryType.Local"/>
            /// implying dedicated local memory storage such as SRAM, or <see cref="NOpenCL.LocalMemoryType.Global"/>.
            /// For custom devices, <see cref="NOpenCL.LocalMemoryType.None"/> can also be returned indicating
            /// no local memory support.
            /// </summary>
            public static readonly DeviceParameterInfo<uint> LocalMemoryType = (DeviceParameterInfo<uint>)new ParameterInfoUInt32(0x1022);

            /// <summary>
            /// Maximum configured clock frequency of the device in MHz.
            /// </summary>
            public static readonly DeviceParameterInfo<uint> MaxClockFrequency = (DeviceParameterInfo<uint>)new ParameterInfoUInt32(0x100C);

            /// <summary>
            /// The number of parallel compute units on the OpenCL device. A work-group
            /// executes on a single compute unit. The minimum value is 1.
            /// </summary>
            public static readonly DeviceParameterInfo<uint> MaxComputeUnits = (DeviceParameterInfo<uint>)new ParameterInfoUInt32(0x1002);

            /// <summary>
            /// Max number of arguments declared with the <c>__constant</c> qualifier in
            /// a kernel. The minimum value is 8 for devices that are not of type <see cref="NOpenCL.DeviceType.Custom"/>.
            /// </summary>
            public static readonly DeviceParameterInfo<uint> MaxConstantArguments = (DeviceParameterInfo<uint>)new ParameterInfoUInt32(0x1021);

            /// <summary>
            /// Max size in bytes of a constant buffer allocation. The minimum value is 64
            /// KB for devices that are not of type <see cref="NOpenCL.DeviceType.Custom"/>.
            /// </summary>
            public static readonly DeviceParameterInfo<ulong> MaxConstantBufferSize = (DeviceParameterInfo<ulong>)new ParameterInfoUInt64(0x1020);

            /// <summary>
            /// Max size of memory object allocation in bytes. The minimum value is max
            /// (1/4th of <see cref="GlobalMemorySize"/>, 128*1024*1024) for devices that are
            /// not of type <see cref="NOpenCL.DeviceType.Custom"/>.
            /// </summary>
            public static readonly DeviceParameterInfo<ulong> MaxMemoryAllocationSize = (DeviceParameterInfo<ulong>)new ParameterInfoUInt64(0x1010);

            /// <summary>
            /// Max size in bytes of the arguments that can be passed to a kernel. The
            /// minimum value is 1024 for devices that are not of type <see cref="NOpenCL.DeviceType.Custom"/>.
            /// For this minimum value, only a maximum of 128 arguments can be passed to a kernel.
            /// </summary>
            public static readonly DeviceParameterInfo<UIntPtr> MaxParameterSize = (DeviceParameterInfo<UIntPtr>)new ParameterInfoUIntPtr(0x1017);

            /// <summary>
            /// Max number of simultaneous image objects that can be read by a kernel.
            /// The minimum value is 128 if <see cref="ImageSupport"/> is true.
            /// </summary>
            public static readonly DeviceParameterInfo<uint> MaxReadImageArguments = (DeviceParameterInfo<uint>)new ParameterInfoUInt32(0x100E);

            /// <summary>
            /// Maximum number of samplers that can be used in a kernel. The minimum value
            /// is 16 if <see cref="ImageSupport"/> is true.
            /// </summary>
            /// <seealso cref="Sampler"/>
            public static readonly DeviceParameterInfo<uint> MaxSamplers = (DeviceParameterInfo<uint>)new ParameterInfoUInt32(0x1018);

            /// <summary>
            /// Maximum number of work-items in a work-group executing a kernel on a single
            /// compute unit, using the data parallel execution model.
            /// (Refer to <see cref="clEnqueueNDRangeKernel"/>). The minimum value is 1.
            /// </summary>
            public static readonly DeviceParameterInfo<UIntPtr> MaxWorkGroupSize = (DeviceParameterInfo<UIntPtr>)new ParameterInfoUIntPtr(0x1004);

            /// <summary>
            /// Maximum dimensions that specify the global and local work-item IDs used by
            /// the data parallel execution model. (Refer to <see cref="clEnqueueNDRangeKernel"/>). The
            /// minimum value is 3 for devices that are not of type <see cref="NOpenCL.DeviceType.Custom"/>.
            /// </summary>
            public static readonly DeviceParameterInfo<uint> MaxWorkItemDimensions = (DeviceParameterInfo<uint>)new ParameterInfoUInt32(0x1003);

            /// <summary>
            /// Maximum number of work-items that can be specified in each dimension of
            /// the work-group to <see cref="clEnqueueNDRangeKernel"/>.
            /// <para/>
            /// Returns <em>n</em> <see cref="IntPtr"/> entries, where <em>n</em> is the
            /// value returned by the query for <see cref="MaxWorkItemDimensions"/>.
            /// <para/>
            /// The minimum value is (1, 1, 1) for devices that are not of type <see cref="NOpenCL.DeviceType.Custom"/>.
            /// </summary>
            public static readonly DeviceParameterInfo<UIntPtr[]> MaxWorkItemSizes = (DeviceParameterInfo<UIntPtr[]>)new ParameterInfoUIntPtrArray(0x1005);

            /// <summary>
            /// Max number of simultaneous image objects that can be written to by a
            /// kernel. The minimum value is 8 if <see cref="ImageSupport"/> is true.
            /// </summary>
            public static readonly DeviceParameterInfo<uint> MaxWriteImageArguments = (DeviceParameterInfo<uint>)new ParameterInfoUInt32(0x100F);

            /// <summary>
            /// The minimum value is the size (in bits) of the largest OpenCL built-in
            /// data type supported by the device (long16 in FULL profile, long16 or
            /// int16 in EMBEDDED profile) for devices that are not of type <see cref="NOpenCL.DeviceType.Custom"/>.
            /// </summary>
            public static readonly DeviceParameterInfo<uint> MemoryBaseAddressAlignment = (DeviceParameterInfo<uint>)new ParameterInfoUInt32(0x1019);

            /// <summary>
            /// Deprecated in OpenCL 1.2. The smallest alignment in bytes which can be
            /// used for any data type.
            /// </summary>
            [Obsolete("Deprecated in OpenCL 1.2")]
            public static readonly DeviceParameterInfo<uint> MinDataTypeAlignment = (DeviceParameterInfo<uint>)new ParameterInfoUInt32(0x101A);

            /// <summary>
            /// Device name string.
            /// </summary>
            public static readonly DeviceParameterInfo<string> Name = (DeviceParameterInfo<string>)new ParameterInfoString(0x102B);

            /// <summary>
            /// Returns the native ISA vector width. The vector width is defined as
            /// the number of scalar elements that can be stored in the vector.
            /// </summary>
            public static readonly DeviceParameterInfo<uint> NativeVectorWidthChar = (DeviceParameterInfo<uint>)new ParameterInfoUInt32(0x1036);

            /// <summary>
            /// Returns the native ISA vector width. The vector width is defined as
            /// the number of scalar elements that can be stored in the vector.
            /// </summary>
            public static readonly DeviceParameterInfo<uint> NativeVectorWidthShort = (DeviceParameterInfo<uint>)new ParameterInfoUInt32(0x1037);

            /// <summary>
            /// Returns the native ISA vector width. The vector width is defined as
            /// the number of scalar elements that can be stored in the vector.
            /// </summary>
            public static readonly DeviceParameterInfo<uint> NativeVectorWidthInt = (DeviceParameterInfo<uint>)new ParameterInfoUInt32(0x1038);

            /// <summary>
            /// Returns the native ISA vector width. The vector width is defined as
            /// the number of scalar elements that can be stored in the vector.
            /// </summary>
            public static readonly DeviceParameterInfo<uint> NativeVectorWidthLong = (DeviceParameterInfo<uint>)new ParameterInfoUInt32(0x1039);

            /// <summary>
            /// Returns the native ISA vector width. The vector width is defined as
            /// the number of scalar elements that can be stored in the vector.
            /// </summary>
            public static readonly DeviceParameterInfo<uint> NativeVectorWidthFloat = (DeviceParameterInfo<uint>)new ParameterInfoUInt32(0x103A);

            /// <summary>
            /// Returns the native ISA vector width. The vector width is defined as
            /// the number of scalar elements that can be stored in the vector.
            /// <para/>
            /// If double precision is not supported, this must return 0.
            /// </summary>
            public static readonly DeviceParameterInfo<uint> NativeVectorWidthDouble = (DeviceParameterInfo<uint>)new ParameterInfoUInt32(0x103B);

            /// <summary>
            /// Returns the native ISA vector width. The vector width is defined as
            /// the number of scalar elements that can be stored in the vector.
            /// <para/>
            /// If the <c>cl_khr_fp16</c> extension is not supported, this must return 0.
            /// </summary>
            public static readonly DeviceParameterInfo<uint> NativeVectorWidthHalf = (DeviceParameterInfo<uint>)new ParameterInfoUInt32(0x103C);

            /// <summary>
            /// OpenCL C version string. Returns the highest OpenCL C version supported
            /// by the compiler for this device that is not of type <see cref="NOpenCL.DeviceType.Custom"/>.
            /// This version string has the following format:
            /// <para/>
            /// <em>OpenCL<space>C<space><major_version.minor_version><space><vendor-specific information></em>
            /// <para/>
            /// The <em>major_version.minor_version</em> value returned must be 1.2 if <see cref="Version"/> is OpenCL 1.2.
            /// <para/>
            /// The <em>major_version.minor_version</em> value returned must be 1.1 if <see cref="Version"/> is OpenCL 1.1.
            /// </summary>
            public static readonly DeviceParameterInfo<string> OpenCLVersion = (DeviceParameterInfo<string>)new ParameterInfoString(0x103D);

            /// <summary>
            /// Returns the <see cref="ClDeviceID"/> of the parent device to which
            /// this sub-device belongs. If device is a root-level device,
            /// <see cref="IntPtr.Zero"/> is returned.
            /// </summary>
            public static readonly DeviceParameterInfo<IntPtr> ParentDevice = (DeviceParameterInfo<IntPtr>)new ParameterInfoIntPtr(0x1042);

            /// <summary>
            /// Returns the maximum number of sub-devices that can be created when a
            /// device is partitioned. The value returned cannot exceed <see cref="MaxComputeUnits"/>.
            /// </summary>
            public static readonly DeviceParameterInfo<uint> PartitionMaxSubDevices = (DeviceParameterInfo<uint>)new ParameterInfoUInt32(0x1043);

            /// <summary>
            /// Returns the list of partition types supported by device. This is an array
            /// of <see cref="PartitionProperty"/> values drawn from the following list:
            ///
            /// <list type="bullet">
            /// <item><see cref="PartitionProperty.PartitionEqually"/></item>
            /// <item><see cref="PartitionProperty.PartitionByCounts"/></item>
            /// <item><see cref="PartitionProperty.PartitionByAffinityDomain"/></item>
            /// </list>
            ///
            /// If the device does not support any partition types, a value of 0 will be returned.
            /// </summary>
            public static readonly DeviceParameterInfo<IntPtr[]> PartitionProperties = (DeviceParameterInfo<IntPtr[]>)new ParameterInfoIntPtrArray(0x1044);

            /// <summary>
            /// Returns the list of supported affinity domains for partitioning the device
            /// using <see cref="PartitionProperty.PartitionByAffinityDomain"/>. This is a
            /// bit-field that describes one or more of the following values:
            ///
            /// <list type="bullet">
            /// <item><see cref="AffinityDomain.Numa"/></item>
            /// <item><see cref="AffinityDomain.L4Cache"/></item>
            /// <item><see cref="AffinityDomain.L3Cache"/></item>
            /// <item><see cref="AffinityDomain.L2Cache"/></item>
            /// <item><see cref="AffinityDomain.L1Cache"/></item>
            /// <item><see cref="AffinityDomain.NextPartitionable"/></item>
            /// </list>
            ///
            /// If the device does not support any affinity domains, <see cref="AffinityDomain.None"/> will be returned.
            /// </summary>
            public static readonly DeviceParameterInfo<ulong> PartitionAffinityDomain = (DeviceParameterInfo<ulong>)new ParameterInfoUInt64(0x1045);

            /// <summary>
            /// Returns the properties argument specified in <see cref="clCreateSubDevices"/>
            /// if device is a subdevice. Otherwise the implementation may either return a
            /// <em>param_value_size_ret</em> of 0 i.e. there is no partition type associated
            /// with device or can return a property value of 0 (where 0 is used to terminate
            /// the partition property list) in the memory that <em>param_value</em> points to.
            /// </summary>
            public static readonly DeviceParameterInfo<IntPtr[]> PartitionType = (DeviceParameterInfo<IntPtr[]>)new ParameterInfoIntPtrArray(0x1046);

            /// <summary>
            /// The platform associated with this device.
            /// </summary>
            public static readonly DeviceParameterInfo<IntPtr> Platform = (DeviceParameterInfo<IntPtr>)new ParameterInfoIntPtr(0x1031);

            /// <summary>
            /// Preferred native vector width size for built-in scalar types that can be put
            /// into vectors. The vector width is defined as the number of scalar elements
            /// that can be stored in the vector.
            /// </summary>
            public static readonly DeviceParameterInfo<uint> PreferredVectorWidthChar = (DeviceParameterInfo<uint>)new ParameterInfoUInt32(0x1006);

            /// <summary>
            /// Preferred native vector width size for built-in scalar types that can be put
            /// into vectors. The vector width is defined as the number of scalar elements
            /// that can be stored in the vector.
            /// </summary>
            public static readonly DeviceParameterInfo<uint> PreferredVectorWidthShort = (DeviceParameterInfo<uint>)new ParameterInfoUInt32(0x1007);

            /// <summary>
            /// Preferred native vector width size for built-in scalar types that can be put
            /// into vectors. The vector width is defined as the number of scalar elements
            /// that can be stored in the vector.
            /// </summary>
            public static readonly DeviceParameterInfo<uint> PreferredVectorWidthInt = (DeviceParameterInfo<uint>)new ParameterInfoUInt32(0x1008);

            /// <summary>
            /// Preferred native vector width size for built-in scalar types that can be put
            /// into vectors. The vector width is defined as the number of scalar elements
            /// that can be stored in the vector.
            /// </summary>
            public static readonly DeviceParameterInfo<uint> PreferredVectorWidthLong = (DeviceParameterInfo<uint>)new ParameterInfoUInt32(0x1009);

            /// <summary>
            /// Preferred native vector width size for built-in scalar types that can be put
            /// into vectors. The vector width is defined as the number of scalar elements
            /// that can be stored in the vector.
            /// </summary>
            public static readonly DeviceParameterInfo<uint> PreferredVectorWidthFloat = (DeviceParameterInfo<uint>)new ParameterInfoUInt32(0x100A);

            /// <summary>
            /// Preferred native vector width size for built-in scalar types that can be put
            /// into vectors. The vector width is defined as the number of scalar elements
            /// that can be stored in the vector.
            /// <para/>
            /// If double precision is not supported, this must return 0.
            /// </summary>
            public static readonly DeviceParameterInfo<uint> PreferredVectorWidthDouble = (DeviceParameterInfo<uint>)new ParameterInfoUInt32(0x100B);

            /// <summary>
            /// Preferred native vector width size for built-in scalar types that can be put
            /// into vectors. The vector width is defined as the number of scalar elements
            /// that can be stored in the vector.
            /// <para/>
            /// If the <c>cl_khr_fp16</c> extension is not supported, this must return 0.
            /// </summary>
            public static readonly DeviceParameterInfo<uint> PreferredVectorWidthHalf = (DeviceParameterInfo<uint>)new ParameterInfoUInt32(0x1034);

            /// <summary>
            /// Maximum size of the internal buffer that holds the output of printf calls from
            /// a kernel. The minimum value for the FULL profile is 1 MB.
            /// </summary>
            public static readonly DeviceParameterInfo<UIntPtr> PrintfBufferSize = (DeviceParameterInfo<UIntPtr>)new ParameterInfoUIntPtr(0x1049);

            /// <summary>
            /// Is true if the device's preference is for the user to be responsible for
            /// synchronization, when sharing memory objects between OpenCL and other APIs
            /// such as DirectX, false if the device / implementation has a performant path
            /// for performing synchronization of memory object shared between OpenCL and
            /// other APIs such as DirectX.
            /// </summary>
            public static readonly DeviceParameterInfo<bool> PreferredInteropUserSync = (DeviceParameterInfo<bool>)new ParameterInfoBoolean(0x1048);

            /// <summary>
            /// OpenCL profile string. Returns the profile name supported by the device
            /// (see note). The profile name returned can be one of the following strings:
            ///
            /// <list type="bullet">
            /// <item>FULL_PROFILE - if the device supports the OpenCL specification (functionality defined as part of the core specification and does not require any extensions to be supported).</item>
            /// <item>EMBEDDED_PROFILE - if the device supports the OpenCL embedded profile.</item>
            /// </list>
            /// </summary>
            public static readonly DeviceParameterInfo<string> Profile = (DeviceParameterInfo<string>)new ParameterInfoString(0x102E);

            /// <summary>
            /// Describes the resolution of device timer. This is measured in nanoseconds.
            /// </summary>
            public static readonly DeviceParameterInfo<UIntPtr> ProfilingTimerResolution = (DeviceParameterInfo<UIntPtr>)new ParameterInfoUIntPtr(0x1025);

            /// <summary>
            /// Describes the command-queue properties supported by the device. This is
            /// a bit-field that describes one or more of the following values:
            ///
            /// <list type="bullet">
            /// <item><see cref="CommandQueueProperties.OutOfOrderExecutionModeEnable"/></item>
            /// <item><see cref="CommandQueueProperties.ProfilingEnable"/></item>
            /// </list>
            ///
            /// These properties are described in the table for <see cref="clCreateCommandQueue"/>.
            /// The mandated minimum capability is <see cref="CommandQueueProperties.ProfilingEnable"/>.
            /// </summary>
            public static readonly DeviceParameterInfo<ulong> QueueProperties = (DeviceParameterInfo<ulong>)new ParameterInfoUInt64(0x102A);

            /// <summary>
            /// Returns the device reference count. If the device is a root-level device,
            /// a reference count of one is returned.
            /// </summary>
            public static readonly DeviceParameterInfo<uint> ReferenceCount = (DeviceParameterInfo<uint>)new ParameterInfoUInt32(0x1047);

            /// <summary>
            /// Describes single precision floating-point capability of the device.
            /// This is a bit-field that describes one or more of the following values:
            ///
            /// <list type="bullet">
            /// <item><see cref="FloatingPointConfiguration.Denorm"/> - denorms are supported.</item>
            /// <item><see cref="FloatingPointConfiguration.InfNaN"/> - INF and quiet NaNs are supported.</item>
            /// <item><see cref="FloatingPointConfiguration.RoundToNearest"/> - round to nearest even rounding mode supported.</item>
            /// <item><see cref="FloatingPointConfiguration.RoundToZero"/> - round to zero rounding mode supported.</item>
            /// <item><see cref="FloatingPointConfiguration.RoundToInf"/> - round to +ve and -ve infinity rounding modes supported.</item>
            /// <item><see cref="FloatingPointConfiguration.Fma"/> - IEEE754-2008 fused multiply-add is supported.</item>
            /// <item><see cref="FloatingPointConfiguration.CorrectlyRoundedDivideSqrt"/> - divide and sqrt are correctly rounded as defined by the IEEE754 specification.</item>
            /// <item><see cref="FloatingPointConfiguration.SoftFloat"/> - Basic floating-point operations (such as addition, subtraction, multiplication) are implemented in software.</item>
            /// </list>
            ///
            /// The mandated minimum floating-point capability for devices that are
            /// not of type <see cref="NOpenCL.DeviceType.Custom"/> is
            /// <see cref="FloatingPointConfiguration.RoundToNearest"/> |
            /// <see cref="FloatingPointConfiguration.InfNaN"/>.
            /// </summary>
            public static readonly DeviceParameterInfo<ulong> SingleFloatingPointConfiguration = (DeviceParameterInfo<ulong>)new ParameterInfoUInt64(0x101B);

            /// <summary>
            /// The OpenCL device type. Currently supported values are one of or a
            /// combination of: <see cref="NOpenCL.DeviceType.Cpu"/>, <see cref="NOpenCL.DeviceType.Gpu"/>,
            /// <see cref="NOpenCL.DeviceType.Accelerator"/>, <see cref="NOpenCL.DeviceType.Default"/>, a
            /// combination of the above types, or <see cref="NOpenCL.DeviceType.Custom"/>.
            /// </summary>
            public static readonly DeviceParameterInfo<ulong> DeviceType = (DeviceParameterInfo<ulong>)new ParameterInfoUInt64(0x1000);

            /// <summary>
            /// Vendor name string.
            /// </summary>
            public static readonly DeviceParameterInfo<string> Vendor = (DeviceParameterInfo<string>)new ParameterInfoString(0x102C);

            /// <summary>
            /// A unique device vendor identifier. An example of a unique device identifier
            /// could be the PCIe ID.
            /// </summary>
            public static readonly DeviceParameterInfo<uint> VendorID = (DeviceParameterInfo<uint>)new ParameterInfoUInt32(0x1001);

            /// <summary>
            /// OpenCL version string. Returns the OpenCL version supported by the device.
            /// This version string has the following format:
            /// <para/>
            /// <em>OpenCL<space><major_version.minor_version><space><vendor-specific information></em>
            /// <para/>
            /// The <em>major_version.minor_version</em> value returned will be 1.1.
            /// </summary>
            public static readonly DeviceParameterInfo<string> Version = (DeviceParameterInfo<string>)new ParameterInfoString(0x102F);

            /// <summary>
            /// OpenCL software driver version string in the form <em>major_number.minor_number</em>.
            /// </summary>
            public static readonly DeviceParameterInfo<string> DriverVersion = (DeviceParameterInfo<string>)new ParameterInfoString(0x102D);
        }

        public sealed class DeviceParameterInfo<T>
        {
            private readonly ParameterInfo<T> _parameterInfo;

            public DeviceParameterInfo(ParameterInfo<T> parameterInfo)
            {
                if (parameterInfo == null)
                    throw new ArgumentNullException(nameof(parameterInfo));

                _parameterInfo = parameterInfo;
            }

            public static explicit operator DeviceParameterInfo<T>(ParameterInfo<T> parameterInfo)
            {
                return new DeviceParameterInfo<T>(parameterInfo);
            }

            public ParameterInfo<T> ParameterInfo
            {
                get
                {
                    return _parameterInfo;
                }
            }
        }
    }
}

redpajama_set_name: RedPajamaGithub


text:
/**
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package tools.descartes.teastore.persistence.domain.converters;

import java.sql.Timestamp;
import java.time.LocalDateTime;

import jakarta.persistence.AttributeConverter;
import jakarta.persistence.Converter;

/**
 * Converter for persisting Java8 LocalDateTime in database.
 * @author Joakim von Kistowski
 *
 */
@Converter(autoApply = true)
public class LocalDateTimeAttributeConverter implements AttributeConverter<LocalDateTime, Timestamp> {

	/**
	 * Converts LocalDateTime to a supported format.
	 * @param locDateTime The date time to convert.
	 * @return The date time in a supported format.
	 */
	@Override
	public Timestamp convertToDatabaseColumn(LocalDateTime locDateTime) {
		if (locDateTime == null) {
			return null;
		}
		return Timestamp.valueOf(locDateTime);
	}

	/**
	 * Converts database format to LocalDateTime.
	 * @param sqlTimestamp The date time to convert.
	 * @return The date as LocalDateTime.
	 */
	@Override
	public LocalDateTime convertToEntityAttribute(Timestamp sqlTimestamp) {
		if (sqlTimestamp == null) {
			return null;
		}
		return sqlTimestamp.toLocalDateTime();
	}
}


With the possibility of glyphosate-resistant kochia in some areas, a proactive approach is needed for weed management in cropping systems. Crop rotation is a strategy that includes the use of multiple management tactics and herbicides with different modes of action. Kochia should be controlled aggressively in Roundup Ready® corn where more effective herbicide options are available. Using multiple herbicides, instead of only glyphosate, adds diversity to weed management programs in Roundup Ready® sugarbeets.
For more information on managing Kochia in a corn and sugarbeet rotation, check out this article from Roundup Ready PLUS®.


text:
The Surfing Song Book ist ein Musikalbum der US-amerikanischen Band The Rincon Surfside Band.

Die 1965 erschienene LP ist für die Geschichte der Popmusik von besonderer Bedeutung, da es sich um das erste Karaoke-Album handelte. Die LP enthält 12 Surf-Songs, von denen die meisten durch erfolgreiche Aufnahmen der Beach Boys und des damals sehr populären Duos Jan and Dean bekannt waren. Diese Songs wurden für The Surfing Song Book neu aufgenommen, wobei die Gesangsparts fortgelassen wurden, sodass die Tracks nur aus Instrumentalparts und Background Vocals bestanden. Die Liedtexte wurden auf die Rückseite der LP-Hülle gedruckt, so dass man die Schallplatte abspielen und dabei selbst die Gesangsparts übernehmen konnte.

Obwohl The Surfing Song Book als eine LP der The Rincon Surfside Band veröffentlicht wurde, existierte diese Band nicht wirklich. Das Album war eine Produktion der Surf-Komponisten Phil Sloan und Steve Barri, die für dieses Projekt professionelle Studiomusiker engagierten, von denen die meisten bereits an den Originalaufnahmen der verschiedenen Songs mitgewirkt hatten und die daher ihre Parts auswendig beherrschten. Die beteiligten Musiker waren Hal Blaine (Schlagzeug), Al DeLory (Orgel), Joe Osborn (Bass), Bill Pittman (Bass) und Tommy Tedesco (Gitarre) sowie Steve Barri (Percussion) und Phil Sloan (Gitarre) selber. Die Aufnahmesession für The Surfing Song Book fand am 21. Mai 1965 im Western Recorders Studio in Hollywood statt. Das fertiggestellte Album wurde im Juli 1965 von Dunhill Records als erste Platte dieses Labels überhaupt veröffentlicht.

Trackliste

 Surfin' Safari (Brian Wilson / Mike Love)
 Surfer Girl (Brian Wilson)
 Sidewalk Surfin (Roger Christian / Brian Wilson)
 Surfin' U.S.A. (Chuck Berry / Brian Wilson)
 Surfin (Brian Wilson / Mike Love)
 Ride The Wild Surf (Jan Berry / Roger Christian / Brian Wilson)
 Hawaii (Brian Wilson)
 Drag City (Jan Berry / Roger Christian / Brian Wilson)
 Little Deuce Coupe (Jan Berry / Roger Christian)
 Honolulu Lulu (Jan Berry / Roger Christian / Lou Adler)
 Surf City (Brian Wilson / Jan Berry)
 Skateboard Craze (Phil Sloan / Steve Barri)

Album (Pop)
Surf
Album 1965

redpajama_set_name: RedPajamaWikipedia


This is a post I've been meaning to write for a long time but I recently came across a search which demonstrates the idea perfectly so I decided it was time to put my thoughts down on paper (so to speak).
You can see that 5 of the top 6 results are owned by the times (clicking on www.the-times.co.uk, www.thetimes.co.uk & www.sunday-times.co.uk all redirect you to the main times website which ranks number 1).
Ah-ha! While they have 301 redirected the root page they have forgotten to 301 redirect their robots.txt file which still instructs the search engines not to crawl the website. Since the search engines look at the robots.txt first before they crawl the rest of the site they're not getting as far as the 301. Since Google doesn't know the domains redirect they are still able to rank in their own right (without a snippet of course).
http://www.tom-critchlow.co.uk is a 302 redirect to my page on the Distilled site and ranks number one in yahoo for a search for my name. I haven't dropped many links to it yet so Google hasn't picked it up yet but I'm fairly sure it will in due course.
The first and most obvious drawback to this method is that the links which point to your spare domain are not passing any link juice onto your main website. Between those domains there are 267,700 links which are not passing any value to the main times website. Since these links are links which your main site could easily have gained it seems a waste not to get any value out of them for your main site.
The third issue is more hypothetical but in my eyes you run the risk of Google changing the way it handles 302 redirects or pages behind a robots.txt. In my eyes, the above search results don't add that much value to the user since the top results all point to the same website so I think you run the risk of these search results disappearing at some stage. If you're relying on these pages for reputation management then they could disappear overnight further down the line.
The major benefit of this method which springs to mind is that you don't have to fragment your traffic. All those sites point to your main content and so you don't lose any traffic to mini-sites or profile pages.
The second benefit is that these domains are really quick, easy and cheap to set up. Setting up a mini-site or creating some kind of secondary online presence to rank with can be an expensive project and difficult to get past a company's marketing department. By using this method you neatly sidestep all of those concerns.
Ensure the keyphrase is in the URL - since the search engines can't get any indication of relevance from the content on the site you need to ensure that they can get relevance from the domain name. You'll also need a fair number of anchor text rich links, the number will depend on how competitive your search term is.
Unlike pages behind a robots.txt the search engines actually crawl 302 redirects and look at the landing page to determine what snippet should be displayed therefore it's worth paying attention to which page you're redirecting to ensure that your snippet and title are sensible and relevant.
I'm sure there will be more tips and tricks on their way as I experiment with linking to tom critchlow from a few more places but if anyone else wants to share some tips on how to rank 302'd domains or pages behind robots.txt please shout out in the comments!


Many events are available for our students at Holy Spirit Parish. Please see attached information for further details.
Friday October 28th, Holy Spirit Parish will be hosting an "All Saint's Party" from 6:30-8:30 PM in the Parish Hall. All children are welcome and there is no cost. Children must however be signed in and out by a parent. They may dress as their favourite Saint or come in their Halloween costume, although costumes are optional. Grade 7 Confirmation students can also complete community service hours by helping at this event. We have lots of games and activities planned !!


as the predicted and much-hyped snow never happened.
while the hard rains do not make for pretty scenes.
green grasses and red anemones.
but also for the stormy situation in the Middle East and around the world.
In Israel there is no official Mother's Day or Father's Day.
Family Day is celebrated on Rosh Chodesh Adar, the first day of Adar.
and help light the candles at a Shabbat party.
It is these lights of Jewish heritage and values that burn in Israel.
not of war or hate.
Wouldn't it be wonderful if these children had peaceful neighbors?
love your photos, thanx! keep up the great work!
Thanks Rochel appreciate you taking the time to comment, and being supportive too.
As always, you capture things we really don't see or know about in the US. I only recently learned about Parents' Day in Israel! And I like your Herman Wouk quote tying the message together!
It was nice bumping into you at the OU Center recently! I can't wait to see your Purim pictures!
Thank you mysending, glad to hear from you!
Need I say that this just might be my favorite post of yours yet? The beautiful photos and your beautiful text tell a tender story about our beautiful granddaughter and her generation, who we pray will soon know peaceful neighbors. Nana was sitting on one of those little chairs in spirit….
Thanks Avril, love your support and compliments!
my favorite post yet:) But in all seriousness, so beautifully written.
Songs of a Shabbat shalom, a peaceful sabbath not of war or hate.


text:
Q: How to install dkim-filter by apt-get? In tutorial, DKIM is installed by
sudo apt-get install dkim-filter

I wonder why on my Ubuntu 10.10, I am unable to do this as I receive error of
E: Unable to locate package dkim-filter

How can I install DKIM by apt-get?

A: Maybe because it is not there anymore in 10.10:
Package "dkim-filter"

WARNING: the "dkim-filter" package was deleted from this repository

Name:   dkim-filter

Description:
DomainKeys Identified Mail (DKIM) Milter implementation
Implements a Sendmail Mail Filter (Milter) for the DomainKeys
Identified Mail (DKIM) standard. DKIM provides a way for senders to
confirm their identity when sending email by adding a cryptographic
signature to the headers of the message.

The dkim-milter implements both signing and verification.

Latest version: *DELETED*
Release:    maverick (10.10)
Level:  base
Repository: universe
Head package:   dkim-milter

However I've found this googling a little bit. Just download the .deb file an install it.

redpajama_set_name: RedPajamaStackExchange


Forum Index > Off-topic Talk > Leafsprings heat treating ?
Posted: Mon 25 Jun, 2007 2:29 pm Post subject: Leafsprings heat treating ?
if you grind out the shape of a sword in a leafspring, is the heat treating anihilated?
Probability are than, yes, you'll just mess the heat-treatment. However, I think it's possible to do it if you take care of cooling the blade with water every few minutes, to be sure it doesn't get hot.
If I remember correctly, someone on the forum did something like that (reshaping a blade) for a basket-hilt customization project.
how do you get the bend out of the spring? you can't forge it cold and if you warm it the heat - treatment is destroyed anyway - except it is air-hardening steel (as i wrote in the training sword topic).
If you want to forge a sword from a spring, you need a forge, good dose of patience and someone competent to teach you.
What about getting a look to the famous book by Jim Hrisoulas, "The Complete Bladesmith: Forging Your Way to Perfection" ?
Leaf springs in the U.S. are usually 5160, which is an oil hardening steel. To straighten the bend you would probably want to heat the entire spring to at least 400 degrees F. but probably not more than 550- this temp range is generally within the tempering specs for spring steel. The trick here is to get the straigtening done before the blade loses too much heat. With a leaf spring this would probably take numerous heats.
Grinding on steel that is already heat treated is done as a matter of course in blade-making, the difference in what you are talking about is that you wiull have a great deal more material to remove than if you rough out the blank before heat treating. All in all it is far from an ideal method for making a sword.
Yeah but just take the toni R. spatha, it is made out from a leaf spring and it looks good to me.
I get from your tone that you feel we're trying to discourage you - far from it, we simply want to inform you of the intricacies of dealing with steel in its many forms, and be aware of what it takes to make a decent sword - it's more than simply grinding out a steel billet. In my humble opinion, if you want to do it, please go for it - there can never be too many sword makers, but I encourage you to do your homework first - you will be the better for it, as will your results. If you simply dive in, you may get some surprises, get discouraged or be disappointed with the results. That would be a Bad Thing.
That being said, go for it, mon ami!
I would grind out the blade without gloves or very thin ones so that as soon as the blade becomes too hot to hold it should be cooled with water. I can see some danger when the blade gets close to being sharp that holding the blade with naked hand could become dangerous.
In any case using short and light passes on the grinding wheel as pressure and too much work without stopping to cool things down can cause localized overheating.
With polished in the white steel overheating might be visible as the steel would start to turn colours as it overheats and thin sections will overheat the fastest.
So avoiding ruining the temper is possible but the pace of the work has to be adapted compared to a piece that will be heat treated later.
My knowledge of this is mostly theoretical but I have made a few knives or short swords a long time ago that where from heat treated steel. In fact one error I made early on was grinding out a blade from a large file. I certainly didn't ruin the heat treat, in fact I should have heated it to around 450 or 500 degrees for a few hours and let it cool slowly because it turned out that the dagger blade I had made from the file was still glass hard and broke in two when I did a test hit on a large log ( piece of firewood ).
I certainly wasn't trying to be discouraging, just trying to give some insight. Bending a heat-treated piece of steel can be a hit or miss operation-there is always the possibility of causing stress fractures or other faults in the steel, which may or may not be apparent. Heating to the tempering range will prevent this to some extent but temperature control is important.
that spatha will likely remember what it was.
leaf springs are forged as curved and as long as you don't re-hammer them hot into something straight they will tend to bend back into shape.
Naturally you can be perfectly content with an at-risk-of-bending-back straight blade.
if you don't look for professional results but you just need a good fun tool you can go that way.
I'm doing a falchion out of a leaf spring and it feels pretty hard under the hammer, after three or four hits steel is already too cool to be moved to shape.
I don't know how much time will take in order to finish it.
It is an extra hard steel for sure.
I thought of something yesterday and i want the opinion of a professional sword maker.
you know that if you want to do an armor piece you can take two things to hammer on the anvil and a stump.
so my question is can we hammer a red hot leaf spring on a wood stump and have a good result?
i forgot to say that i would (if it's a good thing) use the stump for straightening the blade after i making the blade with a leaf spring (if you did not understand) .
I have to say that my spatha has stayed perfectly straight. In my experience leaf spring blades will stay in their shape if you heat them enough to remove the tensions. Of course it will result in a bit poor blade quality, but If you aren´t going to cut anything as hard as bones, it will do just fine. I´ve done some pretty tough cutting with my spatha, and no problems have occured.
I just bought a piece of 5160 from a local supplier. The steel is already tempered and I am going to cut out the sword with an oxy-actelylene torch and grind from there. Years ago, I used this technique to make knives and was very successful. Do what Jean says and wear no gloves and cool frequently with water. I dipped rags into a bucket and slopped the water on while the blade was still clamped in a vise for the coarse shaping grind ( hand disk grinder). I quenched it frequently in a bucket during the final grinding (belt sander).
The pretempered bar steel that I bought is .213" X 2" X 22 ft. The piece cost $43.00. Using straight pretempered steel will get you out of trying to straighten the car spring. My personal experience with car springs is that they have to be heated to cherry red, hammered flat and the re-heated and annealed in order to use them. Otherwise the spring will re-bend when you start working it.
One more thing -if you cut your shape with a torch- cut it oversize and grind to final shape. The area where you make the cut will be affected by the heat - grind away anything that turns blue.
Or do all the profiling with the grinder but expect it to take a long time and many many grinding belts.
By the way the best machines for this type of work are the ones using abrasive belts, the machines using round stone-like abrasive wheels may vibrate too much and the diameter becomes smaller as the wheel wears out.
For rough work one can use a hand held angle grinder with the steel held in a vice moving the grinder instead of moving the steel against a bench grinder: A lot of improvised methods can work but each has it's pitfalls.
Oh, using a dremel and a cutting wheel one could cut a rough profile instead of using the acetylene torch and with less risk of overheating the blade.
If you can find a place to heat treat your finished blade after you have it 95% ground to shape you could avoid all those issues of ruining the temper and the steel will be much faster to grind soft.
I saw something in my town, it was a thing that cuts metal by water pressure. it seems that it cuts it really fast and it doesn't burn the metal. did you know about these things?
because you heated it enough to straiten it, but you surely lost its temper.
being a very good alloy you surely still have a good sword.
But the question here is to avoid losing temper. Heating on an improvised carbon forge as you did cannot be taken into consideration.
As long as this is not the solution, for me it would be.
Surely I have pounded my leaf enough while almost white hot.
I used all the techniques you mention making knives from pre-tempered planer steels - sawmill size bandsaw blades (1/8" thick and very springy) and old files.
I used a bench grinder with a stone wheel only for trimming the jagged edges of the torch cut. Final shaping and the bevels were done on table mounted belt sander using progessively finer belts.
The dremel works well, but I used a larger air driven die grinder. I was fortunate to work in a shop with lot of power tools.
Eventually I graduated to buying annealed tool steels and cutting out the knives on a band saw. I ground and filed the bevels, ricasso, choils handle shapes etc. This made for a much nicer job. I made knives up to 18" long.
Heat treating was done with an oxy-acetylene torch with a rosebud tip and an improvised forge made from pipe lined with asbestos sheeting ( that will tell you how long ago this was). Works fine for knives, but I doubt that you could heat a 36" blade evenly enough for a good heat treat.
Posted: Tue 29 Sep, 2009 1:40 am Post subject: Leafsprings heat treating ?
I try to make a sword from leafspring. Overheating can be avoided, but that's not my primary concern. Leaf springs are already heat-treated, ideal for absorbing shocks, but I dont't think they will have good edge retention. Is there a method for quenching just a few millimeters of the edge, leaving the rest unmodified (like hacksaw blades)?


text:
Courses from Space Pioneers, Explorers, and Innovators
Gain a deeper understanding of leadership styles and their impact in a dynamic environment. Learn to apply new competencies to address change and conflict, through strategic communication and influence, critical thinking, and effective decision-making processes.
Learn about the challenges to human health while living and working in space. Topics are related to the health and well-being of space communities to support long-duration space missions.
Gain insights into space sustainability. Learn about key methods and strategies on identifying, monitoring, and prevention strategies to minimize the impact of human activity throughout the space environment through process based life-cycle assessment approach.
Discover the challenges of space exploration, topics include spaceflight, human factors, technologies to enable humans to live and work in space to become a multi-planetary species.
Learn about legal, regulatory and policies related to space exploration and emerging challenges to existing frameworks. Examine key governance structures and institutions in societies, policy cycles, and the scientific knowledge of laws of government and the lawmaking process.
Explore the challenges of crop production in controlled environments, effective management of ecosystems, and the evolution of agri-food systems in space.
Examine novel and contemporary contexts of education systems through a multitude of perspectives, develop an understanding of professional standards based on principles & practice of quality sciences & management to achieve quality education.
Find out about the evolving challenges of the responsible use of available resources in the Solar System. What will the systems that will take humanity to the thrive beyond LEO look like.
SPACE Skills
Participate in SPACE Skills, Challenges, Contests, and Design Competitions. Explore new opportunities and learn new skills, upskill and reskill, and advance the trajectory of your career at your own pace!
SPACE Courses
Providing SPACE Education, Training, Professional Development and Short-Term Courses for students looking to enhance their skills and transition into the Space Industry. We are here to support your success!
Space Education
Privacy & Support
© 2022 Kepler Space Institute. All Rights Reserved.

redpajama_set_name: RedPajamaCommonCrawl


text:
James Henry Foran (1847 – November 29, 1906) was an American Major League Baseball player from Pennsylvania, and a participant in the first game ever played in a professional baseball league, between his Fort Wayne Kekiongas and the Cleveland Forest Citys on May 4, 1871. Foran had one single in four at-bats, one of only four hits Ft. Wayne had that day; nonetheless, the Kekiongas won, 2-0.

Foran first played in the amateur NABBP in 1869, holding down third base for the original Philadelphia Athletics. He is credited with 147 hits and 147 runs scored against only 89 "hands lost" (one of the best marks on the club), leading the Athletics to a 45-8 record. (A batter was given a "hand lost" every time he made at out at bat or on the base paths.) In 1870, he moved to the Union club of Lansingburgh, New York (who changed their name to the better-known Troy Haymakers in 1871); Foran played the outfield and notched 109 hits in 39 games.

The following season, with the advent of the all-professional National Association, Foran headed to Fort Wayne, Indiana—easily the smallest city in the fledgling circuit. He played mostly first base, but did appear in three games in the outfield. In total, he appeared in 19 games as a member of the Kekiongas, and had a .348 batting average, with 31 hits in 89 at bats—by far the best on the team, and 13th-best in the entire Association. Foran also led the team in hits, runs scored, RBIs, triples, and tied for the team lead in home runs, with one.

Despite the presence of Foran and 19-year-old pitcher Bobby Mathews (who would go on to win nearly 300 MLB games), the Kekiongas franchise folded after compiling a 7-12 record, finishing seventh among the nine teams in the league. Foran never again played in MLB, but, after making his way to California, did play for San Francisco and Oakland clubs in the original California League from 1879-81.

Jim Foran died in Newark, New Jersey, and is interred at the Holy Sepulchre Cemetery in Newark.

References

External links

Major League Baseball first basemen
Philadelphia Athletics (NABBP) players
Troy Haymakers (NABBP) players
Fort Wayne Kekiongas players
Baseball players from Pennsylvania
19th-century baseball players
1847 births
1906 deaths
San Francisco Knickerbockers players
San Francisco Eagles players
San Francisco (minor league baseball) players
Oakland (minor league baseball) players


Ms. Lisa Michelle Kinard was born February 24, 1966 in Tampa, FL to the late Aretha Staggers and the late Curtis Strong.
Lisa was educated in the public schools of Sumter County and was a graduated of Sumter High School.
Lisa enjoyed life and loved to sing. Lisa was a baritone singer for the Singing Angels of Sumter, SC for over thirty years. They traveled throughout the United States singing and lifting up the name of Jesus the Christ. Lisa embraced the stage with some of the nations top gospel recording artists.
Lisa was preceded in death by her mother, Aretha Staggers and her father, Curtis Strong.
Lisa transitioned from this life on Sunday, April 7, 2019 at Prisma Health Tuomey.
Lisa leaves to cherish her memory two daughters, Talisa Kinard (Tyrell) and Jalisa Strong; three sons, Curtis Strong, Ka-cei Green and Roderick Blair; grandchildren, Damontae Lowery, Shamiya Kinard, K'Lynn Kinard, Carter Nelson, Melanie Phenix Strong, Mariyah Nelson and Ty'Ree Nelson; stepmother, Juanita Strong; stepsisters, Dana Singletary Hall, Eva (Samuel) Green; stepbrother, Reggie (Jackie) Singletary; uncle, Henry Epps, Sr.; aunts, Soundra Cooper and Louise Strong; nephews, Reggie Singletary, Jr., Jared Singletary, Jovan Moore and Joshua Moore; god daughter, Toni Wilson; best friend, Brenda Wilson and a host of other relatives and friends.


Gutters and Downspouts need to be clear and free of debris to allow water to flow properly. Over time debris in the form of leaves, shingle granule, dirt and concrete tile build up and need to be removed.
Downspouts need to be checked that they are clear to allow water to shed away from the foundation. Downspouts that are near shrubs and vine type plants can allow roots to grow up through the downspout.
Cleaning of your gutters can include, scooping out by hand, blowing out with a blower or using water from a hose. This can be a messy job, but don't worry we'll clean up after ourselves!
We have a fully equipped seamless gutter machine that is capable of making gutter to any length. We can professionally install new seamless gutter and downspout on your home or business.
Cooler and dryer weather is here. Leaves and debris can pose a fire danger. Are your rain gutters ready? Give us a call and we can clean and inspect them for you.
Atlantis . . . Boynton Beach . . . Boca Raton . . . Briny Breezes . . . Broward County . . . Coconunt Creek . . . Davie . . . Deerfield Beach . . . Delray Beach . . . Ft Lauderdale . . . Hallandale . . . Highland Beach . . . Hollywood . . . Lantana . . . Jupiter . . . Lake Worth . . . Loxahatchee . . . North Palm Beach . . . Parkland . . . Palm Beach Gardens . . . Palm Beach . . . Pembroke Pines . . . Pompano Beach . . . Sunrise . . . West Palm Beach . . . Weston . . . Tamarac . . .


Australian distributors who are supplying Aldi with consumer electronics and appliances are set to get a massive lift in sales as Aldi looks to spend $750 Million pushing into Western and South Australian.
just beat Aldi to be named Britain's best supermarket.
distributors in Australia as well as branded CE and appliance vendors.
what Aldi does to shift products such as TV's, small appliances and tools.
generate high traffic during lunch times.
struggling Big W and Masters stores.
iPhone 5: No Borders, 4 Inch Screen & 2X Processors?


Almost 20 percent of your household energy bill goes towards running your water heater. While it is one of the most utilized appliances in the home, it is often draining on your wallet. In fact, reducing your water heater temperature by just 10 degrees can help you save up to 5 percent on your monthly utilities. However, the desired temperature setting for water heaters can vary wildly from home to home. At Mr. Rooter, we provide professional residential and commercial plumbing services in Atlanta, Roswell, Dunwoody, Sandy Springs, Roswell and other nearby metro area cities. We enjoy helping our local customers get the most from their plumbing system, and we want to help you achieve similar results. Are you wondering which water heater temperature setting is best for your family? Here are a few tips for keeping your hot water in the perfect range for your unique lifestyle and budget.
Don't let your water heater temperature dip below 120 degrees. Doing so could encourage bacterial growth inside your tank, and cause disease or illness.
Water set at 150 degrees or more can cause burns. Households with small children or senior citizens may want to reduce their temperature setting for safety reasons.
If someone in the home has issues with their respiratory or immune system, it's best to keep water at 140 degrees or more to avoid disease causing bacteria.
Couples or solo dwellers may decide to reduce their temperature settings to save even more money.
Households with large families might want to raise the temperature slightly to meet a higher demand for hot water.
Most modern water heaters will have an easy to read manual dial or digital display where the temperature setting can be observed and changed if needed. You can also take the temperature of the hot water using a thermometer while running hot water through the sink or bathtub faucet.
Is your water heater still not meeting your needs, even after adjusting the temperature setting? There are several solutions available. Are you concerned about scalding water but don't want to encourage bacterial growth? You can invest in a hot water tank booster. When in use, your water heater will continue to warm the water in your tank to 140 degrees, but when a faucet is turned on, the booster will mix it with cool alter to lower the temperature to 120 degrees. Do you live in a house with major square footage? It can be difficult to keep the water warm in outlying areas of large homes. Installing a hot water circulating system or tankless on demand water heater can help you get the results you want.
Do you need a water heater repair, replacement, tankless water heater installation or other plumbing maintenance service? Then call the experts at Mr. Rooter of Atlanta, Georgia and get help fast. Our licensed and insured plumbers are proud to provide premium services to local home and business owners. Contact our customer care team today for more information or to schedule your next appointment.


Indie Retro News: WinUAE 3.4.1 Beta 1 - The best Amiga emulator gets a big changelog update!
WinUAE 3.4.1 Beta 1 - The best Amiga emulator gets a big changelog update!
The latest Amiga news to begin the week, as Toni Wilen has once again announced a new Amiga emulator beta as ' WinUAE 3.4.1 Beta 1', which has a ton of fixes and improvements over from WinUAE 3.4.0 released at the end of last year as a Christmas special. This new version which is sure to be updated throughout the year, has a big list of changes such as fixed crash when sound card audio play, implemented accurate 68020+ T0 trace mode emulation and even quickstart Blizzard modes. But as ever please see the changelog for further details.
- Quickstart Blizzard modes (except if JIT enabled) enabled 24-bit addressing which caused new autoconfig/fallback mode support to think Blizzard is in 68020 fallback mode, disabling autoconfig.
- Added Apollo 1240/1260 SCSI module installed on/off option.
- IDE Identify drive command didn't reset multiple sector offset value. If previous read was partial multiple transfer, identity drive returned previously read data block.
- Added Lock drive option to real harddrive mount dialog. If checked, all partitions in selected drive will be locked and unmounted when emulation is running, enabling full read/write access even if drive has Windows mounted FAT partition(s). Lock will be ignored if drive has one or more NTFS partitions.
- Add harddrive didn't accept magneto-optical devices.
- Softfloat FPU mode added to GUI, supports on the fly switching.
- Untrap middle mouse button option was stuck.
- Fixed crash when sound card audio play started and mono sound channel mode and "Include CD and FMV audio" was ticked.
- 271b3 "Blitter final D write don't increase "nasty" count" That is not true, I think this was only added to fix demo that randomly glitches on real hardware too.. Fixes intro Himalaya by Avalanche.
- Added illegal instruction at the end of each memory bank allocation, just outside of last available byte to force exception if execution falls of the edge of memory. This can happen if "more compatible" is not checked. Currently this causes bus error exception. May become halt in the future.
- Emulated sprite special case when DMA mode sprite's start X-coordinate is less than sprite's DMA slot position.
- HAM mode and BPLCON4 BPLAM bit changes or HAM mode and BPLCON4 sprite bank bit changes and sprites in same scanline may have caused wrong sprite or HAM colors.
- >2M chip RAM didn't work in non-JIT compatible modes.
- Added -ldlog 1/2 command line parameter, logs all laserdisc commands.
- Recursive mode ROM scanner now skips directories starting with dot.
- HDF creator used old style dialog type.
- 68030 CE/prefetch mode cache access fix.
- JIT direct broke 512k and 1M chip RAM size detection.
- If statefile is loaded with one or more floppy images that can't be opened: keep fake disk in drive (like previously) and ask for new disk path when missing disk is accessed for the first time. (access = read or write attempt) Old disk path is shown in disk dialog title bar.
- SCSI emulation SCSI buffer re-sizing didn't handle READ(6) zero size length correctly.
- Added memory cycle-exact Quickstart step for A1200 and CD32 configurations. Less CPU heavy than full cycle-exact and usually not much more worse (or better). At least not until 68020 CE gets better.
- Memory cycle exact mode incorrectly counted internal CPU cycles partially.
- Memory cycle exact mode also enables more accurate custom chipset mode.
- 68020 CE mode adjustments, fixed Chip RAM access speed (was too fast previously), removed all extra cycle counting temporarily. Work in progress.
- Include key scancode in Input panel key events.
Softfloat FPU mode is now officially supported, Andreas Grabher (Previous) implemented required 6888x-specific features to softfloat support library. Only needed if "weird" features are required (denormals and unnormals, invalid operands) or extended precision (that WinUAE does not support due to MSVC not supporting it) or accurate status register flags or 100% accurate rounding/NaN handling, FMOD/FREM quotient etc.
Arithmetic exceptions are not yet supported. Trigonometric and logarithmic functions are currently implemented using normal native C-library functions and won't return 100% same results as real 6888x.
Not compatible with JIT FPU emulation.


The comfort and style of your favorite t-shirt and it's waterproof! This short sleeve version of our women's long sleeve rash guard offers light support and extra modesty via a built-in shelf bra. The short sleeve rash guard top keeps you fully covered with extra length in the torso. Perfect for anyone looking for a modest swimsuit top, active wear bathing suit top or women's sun protection clothing. Bottoms sold separately.


and on those in the tomb bestowing life!
(For those with a Summit Choirbook this is #110, Tune 2) It's not easy to sing three times with great gusto at 7:45 in the morning but we did our best. All was going well but then suddenly, Sr. Mary Martin over in the alto section began making strange faces at Sr. Maria who was directing. A look over at the 2nd sopranos showed signs of panic on their faces. By the last repeat which goes up a third we all realized what happened. Sure enough, we were on not our third repeat but our fourth! We managed to hold off the giggles until we finished but probably our guests in the extern chapel were wondering just what was going on.
Could this have something to do with the fact that the rising bell rang at 5:30 instead of 5:20?
Imagine what the rest of the day will be like!
Welcome Home, Sr. Maria Agnes!


← The search for more cost effective ingredients and a bag of guts.
Posted on February 25, 2013 by mswolfspack	• This entry was posted in Uncategorized and tagged BARF Diet, BARF dog food, Canine nutrition, Dog Diet, Dog food, family pet, healthy pet, healthy pets, non-commerical dog food, raw chicken, raw diet, Raw dog food, RAW food, Raw food diet, salmon oil, spoiled pooch, stella and chewy. Bookmark the permalink.
Hey, I'm really glad I found your blog! I just brought a Siberian Husky puppy into my household and my boyfriend and I are trying to find the things that work for us and him. I read your article, "Why RAW?" and I really love your points. I feel like maybe I should consider this diet plan once my puppy (Ash) is older, because I'm not well educated on what and how much he should be eating now. I do, however think that this is something we will consider for the future.
Congratulations on the new pup. Great name too 😉 Thanks for reading. I know I have read that RAW is really good for a growing puppy's joint growth but not having had a puppy myself in a very long time it is a topic I have not done much research on. Great post idea. Maybe I'll have to work on that. Thanks for stopping by. Happy reading! I hope I can be of assistance for you and your dogs.


text:
GENERATION & STORAGE
Energy Source & Distribution
HomeGeneration & StorageAi Group: Hazelwood intervention shouldn't be ruled out
Ai Group: Hazelwood intervention shouldn't be ruled out
Hazelwood Power Station
With the closure of Hazelwood set for the end of the month, the Australian Energy Market Operator (AEMO) has reaffirmed the closure would not compromise energy security.
AEMO released a statement in response to recent media reports regarding the closure.
"As noted in earlier AEMO reports, there are power generation resources available in Victoria and the NEM that currently are not operating at all or to their full capacity that can be made available to replace the power currently supplied by Hazelwood," the statement said.
"AEMO's market analysis reveals these resources exceed the 1600MW capacity of Hazelwood.
"AEMO has the necessary authority to ensure the security of the system and over the next several months will work with market participants in gas and electricity markets to ensure all necessary plans are in place to secure summer reliability."
The statement came before Australian Industry Group (Ai Group) said an "11th hour emergency intervention should not be ruled out".
"With only a week to go until the closure of Victoria's Hazelwood power station, Ai Group's members are not convinced that the risks to energy users are being managed effectively and their confidence in both energy prices and supply is eroding," Ai Group chief executive Innes Willox said.
"While the risks are most acute for energy-intensive industries, they have implications for businesses along all domestic supply chains, their employees as well as for households.
"In the absence of convincing and appropriately sequenced alternative strategies, the state and federal governments should remain open to finding an 11th hour solution to keeping Hazelwood operating in some form."
Prime Minister Malcolm Turnbull told 3AW's Neil Mitchell on Friday his government would not step in to stop the closure of the power station.
He said the decision to close Hazelwood was a commercial one taken by its owner, Engie Australia, who had planned to close the power station for many years.
AEMO
hazel wood power station
National Electricity Market
Previous articleIRENA: Energy-related carbon emissions can be eliminated
Next articleClimate Change Review discussion paper released
Free E-News
Generation 2.0 Summit 2021 (Virtual)
16 Feb @ 8:00 am - 18 Feb @ 5:00 pm
Enlit Australia 2021
21 Jul @ 8:00 am - 22 Jul @ 5:00 pm
National Cleantech Conference and Exhibition
1 Nov @ 8:00 am - 2 Nov @ 5:00 pm
EN2021 Conference & Exhibition
9 Nov @ 8:00 am - 11 Nov @ 5:00 pm
Sign up to receive the latest Energy News emailed directly to your Inbox
Three AGL retailers (AGL) have paid penalties totalling $160,000 after being issued with eight infringement notices - more: https://esdnews.com.au/aer-takes-action-against-agl-for-not-promptly-fixing-customers-meters/ #esdnews #energy @aergovau
Funding from our Community Partnership Program has enabled ErinEarth native garden and The Carevan Foundation to provide vegetables and hot meals for disadvantaged local communities.
#transgrid #energyconnect #community #waggawagga
https://bit.ly/2M2Kntk
© Copyright 2018 Energy Source & Distribution, All Rights Reserved.
Enter your details below to receive a FREE digital copy of Energy Source & Distribution magazine as well as our weekly email newsletter delivered directly to your inbox!


When my children were little I would read them this story and never could I get through it without tearing up and sobbing. They would always smile and say "Awww mom's crying again" and they'd make me read it again and again just so they could get the same reaction over and over again. I'm sure many of you know this delightful book and if you don't please look it up. I guarantee you won't be able to keep your eyes dry either. Here is Robert Munsch reading the book.
And don't forget to join us for our special Mother's Day celebration this Thursday night at Aphrodite at 7 p.m. Trudy Gallagher will be at the store with her fabulous jewellery that we will integrate into a wonderful fashion show. See my earlier post below for more details. Please RSVP tpoder@baseatlantic.ca or call 863-0606.
SO excited to be back at Aphrodite on Thursday for the fashion show and jewellery show! We are bringing special pieces just for your clients. I"m bringing Bruna an exchange student from Brazil who is beyond thrilled to visit.
Great choice of book: my mom gave it to me before she died and I can't read it. It makes me cry too hard, but I still love it.