Почему делает ABI Mac, требуют 16-байтового выравнивания стека для x86-32?

Я полагаю, что это должно сохранить это встроенным с x86-64 ABI.

Для поддержания непротиворечивости в ядре. Это позволяет тому же ядру быть загруженным на нескольких архитектуре без modicfication.

Я не уверен, поскольку у меня нет доказательств из первых рук, но я считаю, что причина в SSE. SSE работает намного быстрее, если ваши буферы уже выровнены по границе 16 байтов (movps vs movups), а любой x86 имеет как минимум sse2 для mac os x. Об этом может позаботиться пользователь приложения, но стоимость довольно значительная. Если общие затраты на то, чтобы сделать его обязательным в ABI, не слишком велики, оно того стоит. SSE широко используется в mac os X: фреймворк для ускорения и т. Д.

Я бы предложил изучить необходимый SQL для обновления соответствующих данных в таблицах. Вы можете использовать операторы SELECT с предложениями ORDER BY для просмотра данных в том порядке, в котором вы хотите их просматривать, а затем создать запрос для обновления этих данных.

Вы можете использовать транзакции, чтобы убедиться, что ваше обновление является правильным, поскольку вы go (если вы все еще изучаете SQL и не хотите портить базу данных).

BEGIN TRANSACTION -- starts a transaction
ROLLBACK          -- stops the transaction and rolls back all changes to the tables
COMMIT            -- stops the transaction and commits all changes to the tables

Что вы пытаетесь выполнить / обновить, может быть, мы можем вам с этим помочь?

EDIT

Вы упомянули что вы хотите отредактировать названия продуктов, хранящиеся в таблице. и что это будет разовая задача. Ниже я установил небольшую демонстрацию, которая, надеюсь, поможет вам найти решение, которое может сработать в вашей ситуации. скопируйте и вставьте это в сеанс SQL Management Studio.

Также, если хотите,

Хм, разве OS X ABI не выполняла забавные RISC-функции вроде передачи небольших структур в регистры?

Так это указывает на согласованность с теорией других платформ.

Приходите к подумайте об этом, API системных вызовов FreeBSD также выравнивает 64-битные значения. (например, lseek и mmap)

Это проблема эффективности.

Убедиться, что 16-байтовый стек выровнен в каждой функции, использующей новые инструкции SSE, добавляет много накладных расходов на использование этих инструкций, эффективно снижая производительность.

С другой стороны, постоянное выравнивание 16-байтового стека гарантирует, что вы можете свободно использовать инструкции SSE без каких-либо штрафов за производительность. Это не требует никаких затрат (затраты измеряются, по крайней мере, в инструкциях). Это включает в себя только изменение константы в прологе функции.

Трата стека дешево, это, вероятно, самая горячая часть кэша.

Так же

With EventStealingInfo
    .RIGHT_DOWN = True
    .RIGHT_UP = True
End With

становится

EventStealingInfo.RIGHT_DOWN = true;
EventStealingInfo.RIGHT_UP = true;

Из вашего комментария: «Я хочу простой и компилировать безопасный по времени синтаксис, чтобы получить информацию о членах».

Это очень часто запрашиваемая функция, которая обсуждалась на совещаниях команды C # в течение примерно десяти лет, но никогда не была достаточно приоритетна, чтобы быть включенной.

Эта запись в блоге объясняет, почему:

http://blogs.msdn.com/ericlippert/archive/2009/05/21/in-foof-we-trust-a-dialogue.aspx

Так что пока вы просто будете бороться против отсутствующей функции. Возможно, вы могли бы опубликовать больше информации о вашей более широкой проблеме и посмотреть, могут ли люди предложить различные подходы.

Обновить

Без дополнительной информации о вашей проблеме это просто догадки. Но если у вас есть свойство, которое представляет значение, но также несет дополнительную «метаинформацию», вы всегда можете представить это как новый тип и использовать шаг «инъекция», чтобы настроить все.

Вот предлагаемый абстрактный интерфейс к такому «свойству meta»:

public interface IMetaProperty<TValue>
{
    TValue Value { get; set; }

    string DisplayName { get; }

    event Action<TValue, TValue> ValueChanged;
}

Значение свойства является всего лишь другим подчиненным свойством, тип которого определяется пользователем.

Я ввел отображаемое имя, а также в качестве бонуса вы получили событие, которое возникает при изменении значения (так что вы получаете «наблюдаемость» бесплатно).

Чтобы иметь свойства, подобные этому в классе, вы бы объявили его следующим образом:

public class SomeClass
{
    public IMetaProperty<string> FirstName { get; private set; }
    public IMetaProperty<string> LastName { get; private set; }
    public IMetaProperty<int> Age { get; private set; }

    public SomeClass() { MetaProperty.Inject(this); }
}

Обратите внимание на то, как параметры в свойствах являются частными. Это останавливает случайную установку самого свойства вместо настройки подчиненного свойства Value.

Это означает, что класс должен настроить эти свойства, чтобы они не были просто null . Он делает это, вызывая метод magic Inject , который может работать над любым классом:

public static class MetaProperty
{
    // Make it convenient for us to fill in the meta information
    private interface IMetaPropertyInit
    {
        string DisplayName { get; set; }
    }

    // Implementation of a meta-property
    private class MetaPropertyImpl<TValue> : IMetaProperty<TValue>, 
                                             IMetaPropertyInit
    {
        private TValue _value;

        public TValue Value
        {
            get { return _value; }
            set
            {
                var old = _value;
                _value = value;
                ValueChanged(old, _value);
            }
        }

        public string DisplayName { get; set; }

        public event Action<TValue, TValue> ValueChanged = delegate { };
    }

    public static void Inject(object target)
    {
        // for each meta property...
        foreach (var property in target.GetType().GetProperties()
            .Where(p => p.PropertyType.IsGenericType && 
                        p.PropertyType.GetGenericTypeDefinition() 
                            == typeof(IMetaProperty<>)))
        {
            // construct an implementation with the correct type
            var impl = (IMetaPropertyInit) 
                typeof (MetaPropertyImpl<>).MakeGenericType(
                    property.PropertyType.GetGenericArguments()
                ).GetConstructor(Type.EmptyTypes).Invoke(null);

            // initialize any meta info (could examine attributes...)
            impl.DisplayName = property.Name;

            // set the value
            property.SetValue(target, impl, null);
        }
    }
}

Он просто использует отражение, чтобы найти все слоты IMetaProperty , скрывающиеся в объекте, и заполняет их реализацией.

Теперь пользователь SomeClass может сказать:

var sc = new SomeClass
             {
                 FirstName = { Value = "Homer" },
                 LastName = { Value = "Simpson" },
                 Age = { Value = 38 },
             };

Console.WriteLine(sc.FirstName.DisplayName + " = " + sc.FirstName.Value);

sc.Age.ValueChanged += (from, to) => 
    Console.WriteLine("Age changed from " + from + " to " + to);

sc.Age.Value = 39;

// sc.Age = null; compiler would stop this

Если вы уже используете контейнер IOC, вы можете достичь некоторых из них, не переходя непосредственно к размышлению.

Во-первых, обратите внимание, что выравнивание на 16 байт является исключением, введенным Apple для System V IA-32 ABI.

Выравнивание стека необходимо только при вызове системных функций, поскольку многие системные библиотеки используют расширения SSE или Altivec, для которых требуется выравнивание 16 байт. Я нашел явную ссылку на странице libgmalloc MAN .

Вы можете идеально обращаться со стековым кадром так, как хотите, но если вы попытаетесь вызвать системную функцию с несоответствующим стеком, вы получите сообщение mosaligned _ stack _ error .

Изменить: Для записи можно устранить проблемы выравнивания при компиляции с GCC с помощью опции mstack-realign .

Я предполагаю, что Apple считает, что все просто используют XCode (GCC), который выравнивает для вас стек. Так что требует выровненного стека, чтобы ядро ​​не должно быть, это просто микрооптимизация.