Пришлось работать по назначению, прекратив использовать forEach, используя только метод pop массива, вызывающий функцию снова для следующей итерации, когда обещание было разрешено или отклонено (должен быть лучший способ сделать это, но пока .. .) Спасибо @Nikita Malyschkin и @MadWard за ответы, но обратный вызов сделал меня немного запутанным для решения @MadWard и не вернул то, что предполагалось, что касается ответа @Nikita, который был немного моим вопросом ... как использовать обещание принудительно синхронизировать цикл foreach (поскольку узел асинхронный).
var net = require('net');
const fs = require('fs');
const async = require("async");
var serverPingList = [
{
port:'80',
domain:'domainexample'
},
{
port:'8089',
domain:'domainexample'
},
{
port:'80',
domain:'domainexample'
},
{
port:'80',
domain:'domainexample'
},
{
port:'80',
domain:'domainexample'
},
]
pingAll();
function pingAll(){
var server = serverPingList.pop();
var client = new net.Socket();
pingPlatforms(server,client)
.then(function(result){
console.log(result);
if(serverPingList.length>0)
pingAll();
}, function(err){
console.log(err);
if(serverPingList.length>0)
pingAll();
});
}
function pingPlatforms(server,client){
return new Promise(function(resolve, reject){
var logInit = `server ${server.domain} and port ${server.port} Connecting...`
var log;
fs.appendFile('ping.log', logInit + '\r\n', (err) => {
if(err)
console.log('Unable to append to server.log.');
});
//console.log(server.port);
//console.log(server.domain);
//https://stackoverflow.com/questions/8588689/node-js-socket-io-client-connect-failed-connect-error-event
//https://nodejs.org/api/net.html#net_socket_connect
console.log('Connecting...')
var socket = client.connect(server.port, server.domain);
socketEvents(socket,client,server).then(function(result){
resolve(result);
}, function(err){
reject(err)
});
/*
socket.on('disconnect', function () {
console.log('Disconnected');
reject('disconnected');
});
*/
/*
socket.on('close', function () {
console.log('socket closed');
//socket.disconnect(0);
//client.destroy();
});
*/
});
}
function socketEvents(socket,client,server){
return new Promise(function(resolve, reject){
//the ping failed
socket.on('error', function(){
var now = new Date().toString();
log = `${now}: server ${server.domain} and port ${server.port} Connection Failed`;
fs.appendFile('ping.log', log + '\r\n', (err) => {
if(err)
console.log('Unable to append to ping.log.');
});
client.destroy();
reject(log);
});
// the ping is successful
socket.on('connect', function(){
console.log('Connected');
var now = new Date().toString();
log = `${now}: server ${server.domain} and port ${server.port} Connection Successful`;
fs.appendFile('ping.log', log + '\r\n', (err) => {
if(err)
console.log('Unable to append to ping.log.');
});
client.destroy();
resolve('success');
});
});
}
С точки зрения скорости работы, GPU оптимизированы для работы с плавающей запятой. Я гораздо больше знаком с аппаратным обеспечением Nvidia, но в аппаратном обеспечении текущего поколения на каждые 8 SP FPU приходится 1 DP. В аппаратном обеспечении следующего поколения, как ожидается, их соотношение будет больше 1 к 2.
Моя рекомендация будет заключаться в том, чтобы посмотреть, нужен ли ваш алгоритм с двойной точностью. Многим алгоритмам на самом деле не нужны лишние биты. Запустите несколько тестов, чтобы определить среднюю ошибку, которую Вы получаете, переходя на единую точность, и выяснить, является ли она существенной. Если нет, просто используйте сингл.
Если ваш алгоритм только для графики, то, скорее всего, вам не нужна двойная точность. Если вы занимаетесь вычислениями общего назначения, то подумайте об использовании OpenCL или CUDA.
Современные графические карты выполняют много оптимизаций, например, они могут даже работать с 24-битными числами. Насколько я знаю, внутренне графические карты не используют двойные, поскольку они созданы для скорости, а не для точности.
Из записи GPGPU в Википедии:
Реализации с плавающей запятой на графических процессорах Nvidia в основном соответствуют IEEE; Однако это не относится ко всем поставщикам. Это имеет значение для правильности, которые считаются важными для некоторых научных приложений. Хотя 64-битные значения с плавающей запятой (с плавающей запятой двойной точности) обычно доступны на процессорах, они не всегда поддерживаются на графических процессорах; некоторые архитектуры GPU жертвуют IEEE-совместимостью, в то время как другим не хватает двойной точности. Были попытки эмулировать значения с плавающей запятой двойной точности на графических процессорах; тем не менее, компромисс между скоростью сводит на нет любые преимущества, прежде всего, для выгрузки вычислений на графический процессор.
Большинство графических процессоров вообще не поддерживают двойное плавание. Поддержка была добавлена совсем недавно (это поколение), и не везде:
Для всего остального, у вас просто нет двойной поддержки.
Итак ... Вам определенно не следует использовать double, если вам это не нужно.
Двойники не поддерживаются для рендеринга до DX11: (т.е. Shader Model 5)
http://msdn.microsoft.com/en-us/library/ee418354(VS.85).aspx
Я подозреваю, что OpenGL будет таким же.