小编Mys*_*ial的帖子

我需要检查C/C++中整数的最低有效位(LSB)和最高有效位(MSB)的值.我该怎么做？

我已经阅读了很多关于花车的内容,但这些都是不必要的.我想我已经理解了它,但我只想知道一件事:

我知道1/pow(2,n),带有n整数的形式的分数可以用浮点数精确表示.这意味着,如果我自己增加1/32了3200万次,我会得到确切的结果1,000,000.

什么样的1/(32+16)？它是两个两个幂之和的一个,这有用吗？或者它1/32+1/16有效吗？这是我很困惑的地方,所以如果有人能为我澄清这一点我会很感激.

我有一个关于openmp编译的问题.

如下代码:

#include <iostream> 
#include <pthread.h>
#include <omp.h>
#include <semaphore.h>
#include <stack>
using namespace std;
sem_t empty,full;
stack<int> stk;
void produce(int i)
{
    {
    sem_wait(&empty);
            cout<<"produce "<<i*i<<endl;
            stk.push(i*i);
    sem_post(&full);
    }
}
void consume1(int &x)
{
    sem_wait(&full);
            int data=stk.top();
            stk.pop();
            x=data;
    sem_post(&empty);
}
void consume2()
{
    sem_wait(&full);
            int data=stk.top();
            stk.pop();
            cout<<"consume2 "<<data<<endl;
    sem_post(&empty);
}
int main()
{
    sem_init(&empty,0,1);
    sem_init(&full,0,0);
    pthread_t t1,t2,t3;
    omp_set_num_threads(3);
    int TID=0;
    #pragma omp parallel private(TID)
    {
            TID=omp_get_thread_num();
            if(TID==0)
            {
            cout<<"There are "<<omp_get_num_threads()<<" threads"<<endl;
            for(int i=0;i<5;i++)
                    produce(i);
            }
            else …

对于高性能计算课程的分配,我需要优化以下代码片段:

int foobar(int a, int b, int N)
{
    int i, j, k, x, y;
    x = 0;
    y = 0;
    k = 256;
    for (i = 0; i <= N; i++) {
        for (j = i + 1; j <= N; j++) {
            x = x + 4*(2*i+j)*(i+2*k);
            if (i > j){
               y = y + 8*(i-j);
            }else{
               y = y + 8*(j-i);
            }
        }
    }
    return x;
}

使用一些建议,我设法优化代码(或至少我认为如此),例如:

1. 不断传播
2. 代数简化
3. 复制传播
4. 常见的Subexpression消除
5. 死代码消除
6. 循环不变量删除
7. 按位移位而不是乘法,因为它们更便宜.

这是我的代码:

int …

我正在寻找IA32上极其快速的atof()实现,针对US-en语言环境,ASCII和非科学表示法进行了优化.Windows多线程CRT在这里惨败,因为它检查每次调用isdigit()时的语言环境变化.我们目前最好的是源自perl + tcl的最佳实现,并且优于msvcrt.dll的atof一个数量级.我想做得更好,但我没有想法.与BCD相关的x86指令似乎很有希望,但我无法让它超越perl/tcl C代码.任何SO'ers都可以找到最好的链接吗？也欢迎基于非x86组件的解决方案.

根据初步答案澄清:

对于该应用,~2 ulp的不准确性是好的.
要转换的数字将通过网络小批量地到达ascii消息,我们的应用程序需要以尽可能低的延迟转换它们.

我们在项目中进行了大量的浮点到整数转换.基本上,这样的事情

for(int i = 0; i < HUGE_NUMBER; i++)
     int_array[i] = float_array[i];

执行转换的默认C函数非常耗时.

是否有任何工作(可能是手动调整功能)可以加快一点点的过程？我们不太关心精度.

Windows API使用GetLastError()机制来检索有关错误或失败的信息.我正在考虑使用相同的机制来处理错误,因为我正在为专有模块编写API.我的问题是API更好地直接返回错误代码？不会GetLastError()有任何特别的优势？考虑下面的简单Win32 API示例:

HANDLE hFile = CreateFile(sFile,
    GENERIC_WRITE, FILE_SHARE_READ,
    NULL, CREATE_NEW, FILE_ATTRIBUTE_NORMAL, NULL);

if (hFile == INVALID_HANDLE_VALUE)
{
    DWORD lrc = GetLastError();

    if (lrc == ERROR_FILE_EXISTS)
    {
          // msg box and so on
    }
}

当我编写自己的API时,我意识到GetLastError()机制意味着CreateFile()必须在所有出口点设置最后一个错误代码.如果有许多退出点并且其中一个可能错过,则这可能会有一点容易出错.愚蠢的问题,但这是如何完成或有某种设计模式呢？

另一种方法是为函数提供一个额外的参数,它可以直接填写错误代码,因此GetLastError()不需要单独的调用.另一种方法可以如下.我将坚持使用上面的Win32 API,这是分析器的好例子.在这里,我将格式更改为此(假设).

result =  CreateFile(hFile, sFile,
    GENERIC_WRITE, FILE_SHARE_READ,
    NULL, CREATE_NEW, FILE_ATTRIBUTE_NORMAL, NULL);

if (result == SUCCESS)
{
   // hFile has correct value, process it
}
else if (result == FILE_ALREADY_EXIT )
{
   // display …

当使用SSE2指令,如PADDD(即_mm_add_epi32内在),有没有办法来检查任何操作是否溢出？

我想也许MXCSR控制寄存器上的标志可能在溢出后设置,但我没有看到这种情况发生.例如,_mm_getcsr()在以下两种情况下打印相同的值(8064):

#include <iostream>
#include <emmintrin.h>

using namespace std;

void main()
{
    __m128i a = _mm_set_epi32(1, 0, 0, 0);
    __m128i b = _mm_add_epi32(a, a);
    cout << "MXCSR:  " << _mm_getcsr() << endl;
    cout << "Result: " << b.m128i_i32[3] << endl;

    __m128i c = _mm_set_epi32((1<<31)-1, 3, 2, 1);
    __m128i d = _mm_add_epi32(c, c);
    cout << "MXCSR:  " << _mm_getcsr() << endl;
    cout << "Result: " << d.m128i_i32[3] << endl;
}

有没有其他方法来检查SSE2的溢出？

我很好奇是否有人可以为我阐明这一点.我正在研究一些数字数据转换的东西,我有几个执行数据转换的函数,我用两个宏定义:

#define CONV_VIA_CAST(name, dtype, vtype)                               \
    static inline void name(void *data, void *view, size_t len) {       \
        vtype *vptr = (vtype*)view;                                     \
        dtype *dptr = (dtype*)data;                                     \
        for (size_t ii=0; ii < len/sizeof(vtype); ii++) {               \
            *vptr++ = (vtype)*dptr++;                                   \
        }                                                               \
    } 


#define CONV_VIA_FUNC(name, dtype, vtype, via)                          \
    static inline void name(void *data, void *view, size_t len) {       \
        vtype *vptr = (vtype*)view;                                     \
        dtype *dptr = (dtype*)data;                                     \
        for (size_t ii=0; ii < len/sizeof(vtype); ii++) {               \
            *vptr++ …

假设您在C/C++中有一个函数,它在第一次运行时表现出某种特定的行为.然后,所有其他时间它表现出另一种方式(例如见下文).在第一次运行之后,if语句变得多余,如果速度很重要,可以将其优化掉.有没有办法进行这种优化？

bool val = true; 

void function1() {

   if (val == true) {
      // do something
      val = false; 
   }
   else {
      // do other stuff, val is never set to true again 
   }

}