Skip to content

Commit 0348e58

Browse files
unbornchikkenunbornchikken
committed
some unnecessary asynchronity removed
1 parent fb386e2 commit 0348e58

14 files changed

+296
-636
lines changed

‎examples/es6/machine-learning/ann.js

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -35,7 +35,7 @@ proto._calculateError = async(function*(out, pred) {
3535
let dif = out.sub(pred);
3636
let sq = dif.mul(dif);
3737
yield this.af.syncAsync();
38-
return Math.sqrt(yield this.af.sumAsync(sq)) / sq.elements();
38+
return 5;//Math.sqrt(yield this.af.sumAsync(sq)) / sq.elements();
3939
});
4040

4141
proto.forwardPropagate = function (input) {

‎examples/es6/machine-learning/neuralNetwork.js

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -39,7 +39,7 @@ let annDemo = async(function*(af, deviceInfo) {
3939
trainTarget,
4040
{
4141
alpha: 1.0,
42-
maxEpochs: 300,
42+
maxEpochs: 5000,
4343
batchSize: 100,
4444
maxError: 0.0001
4545
}

‎src/arrayhelperfunctions.cpp

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -40,9 +40,9 @@ using namespace v8;
4040
using namespace std;
4141
using namespace node;
4242

43-
AF_SM_ARR(IsZero, iszero)
44-
AF_SM_ARR(IsInf, isInf)
45-
AF_SM_ARR(IsNaN, isNaN)
43+
AF_ARR(IsZero, iszero)
44+
AF_ARR(IsInf, isInf)
45+
AF_ARR(IsNaN, isNaN)
4646

4747
NAN_METHOD(Print)
4848
{

‎src/arraywrapper.cpp

Lines changed: 13 additions & 113 deletions
Original file line numberDiff line numberDiff line change
@@ -526,143 +526,43 @@ NAN_METHOD(ArrayWrapper::Scalar)
526526
try
527527
{
528528
ARGS_LEN(1)
529-
529+
Guard guard;
530530
auto pArray = GetArray(info.This());
531-
af::array array(*pArray);
532-
switch (array.type())
531+
switch (pArray->type())
533532
{
534533
case f32:
535-
{
536-
auto exec = [=]()
537-
{
538-
Guard guard;
539-
return array.scalar<float>();
540-
};
541-
auto worker = new Worker<float>(GetCallback(info), move(exec));
542-
Nan::AsyncQueueWorker(worker);
543-
}
534+
info.GetReturnValue().Set(Nan::New(pArray->scalar<float>()));
544535
break;
545536
case f64:
546-
{
547-
auto exec = [=]()
548-
{
549-
Guard guard;
550-
return array.scalar<double>();
551-
};
552-
auto worker = new Worker<double>(GetCallback(info), move(exec));
553-
Nan::AsyncQueueWorker(worker);
554-
}
537+
info.GetReturnValue().Set(Nan::New(pArray->scalar<double>()));
555538
break;
556539
case s32:
557-
{
558-
auto exec = [=]()
559-
{
560-
Guard guard;
561-
return array.scalar<int>();
562-
};
563-
auto worker = new Worker<int>(GetCallback(info), move(exec));
564-
Nan::AsyncQueueWorker(worker);
565-
}
540+
info.GetReturnValue().Set(Nan::New(pArray->scalar<int>()));
566541
break;
567542
case u32:
568-
{
569-
auto exec = [=]()
570-
{
571-
Guard guard;
572-
return array.scalar<unsigned>();
573-
};
574-
auto worker = new Worker<unsigned>(GetCallback(info), move(exec));
575-
Nan::AsyncQueueWorker(worker);
576-
}
543+
info.GetReturnValue().Set(Nan::New(pArray->scalar<unsigned>()));
577544
break;
578545
case u8:
579-
{
580-
auto exec = [=]()
581-
{
582-
Guard guard;
583-
return array.scalar<unsigned char>();
584-
};
585-
auto worker = new Worker<unsigned char>(GetCallback(info), move(exec));
586-
Nan::AsyncQueueWorker(worker);
587-
}
546+
info.GetReturnValue().Set(Nan::New(pArray->scalar<unsigned char>()));
588547
break;
589548
case b8:
590-
{
591-
auto exec = [=]()
592-
{
593-
Guard guard;
594-
return array.scalar<char>();
595-
};
596-
auto worker = new Worker<char>(GetCallback(info), move(exec));
597-
Nan::AsyncQueueWorker(worker);
598-
}
549+
info.GetReturnValue().Set(Nan::New(pArray->scalar<char>()));
599550
break;
600551
case c32:
601-
{
602-
auto exec = [=]()
603-
{
604-
Guard guard;
605-
return array.scalar<af::cfloat>();
606-
};
607-
auto conv = [=](Worker<af::cfloat>* w, af::cfloat data)
608-
{
609-
return ToV8Complex(data);
610-
};
611-
auto worker = new Worker<af::cfloat>(GetCallback(info), move(exec), move(conv));
612-
Nan::AsyncQueueWorker(worker);
613-
}
552+
info.GetReturnValue().Set(ToV8Complex(pArray->scalar<af::cfloat>()));
614553
break;
615554
case c64:
616-
{
617-
auto exec = [=]()
618-
{
619-
Guard guard;
620-
return array.scalar<af::cdouble>();
621-
};
622-
auto conv = [=](Worker<af::cdouble>* w, af::cdouble data)
623-
{
624-
return ToV8Complex(data);
625-
};
626-
auto worker = new Worker<af::cdouble>(GetCallback(info), move(exec), move(conv));
627-
Nan::AsyncQueueWorker(worker);
628-
}
555+
info.GetReturnValue().Set(ToV8Complex(pArray->scalar<af::cdouble>()));
629556
break;
630557
case s64:
631-
{
632-
auto exec = [=]()
633-
{
634-
Guard guard;
635-
return array.scalar<long long>();
636-
};
637-
auto conv = [=](Worker<long long>* w, long long data)
638-
{
639-
Nan::EscapableHandleScope scope;
640-
return scope.Escape(Nan::New(to_string(data).c_str()).ToLocalChecked());
641-
};
642-
auto worker = new Worker<long long>(GetCallback(info), move(exec), move(conv));
643-
Nan::AsyncQueueWorker(worker);
644-
}
558+
info.GetReturnValue().Set(Nan::New(to_string(pArray->scalar<long long>()).c_str()).ToLocalChecked());
645559
break;
646560
case u64:
647-
{
648-
auto exec = [=]()
649-
{
650-
Guard guard;
651-
return array.scalar<unsigned long long>();
652-
};
653-
auto conv = [=](Worker<unsigned long long>* w, unsigned long long data)
654-
{
655-
Nan::EscapableHandleScope scope;
656-
return scope.Escape(Nan::New(to_string(data).c_str()).ToLocalChecked());
657-
};
658-
auto worker = new Worker<unsigned long long>(GetCallback(info), move(exec), move(conv));
659-
Nan::AsyncQueueWorker(worker);
660-
}
561+
info.GetReturnValue().Set(Nan::New(to_string(pArray->scalar<unsigned long long>()).c_str()).ToLocalChecked());
661562
break;
662563
default:
663-
assert(false);
564+
NAN_THROW_INVALID_ARGS();
664565
}
665-
info.GetReturnValue().SetUndefined();
666566
}
667567
ARRAYFIRE_CATCH
668568
}

‎src/computervision.cpp

Lines changed: 31 additions & 79 deletions
Original file line numberDiff line numberDiff line change
@@ -35,7 +35,6 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
3535
#include "arraywrapper.h"
3636
#include "errors.h"
3737
#include "guard.h"
38-
#include "worker.h"
3938

4039
using namespace v8;
4140
using namespace std;
@@ -46,8 +45,8 @@ NAN_METHOD(Orb)
4645

4746
try
4847
{
49-
ARGS_LEN(2);
50-
auto array = *ArrayWrapper::GetArrayAt(info, 0);
48+
ARGS_LEN(1);
49+
auto pArray = ArrayWrapper::GetArrayAt(info, 0);
5150
float fastThr=20.f;
5251
unsigned maxFeat=400;
5352
float sclFctr=1.5f;
@@ -73,26 +72,14 @@ NAN_METHOD(Orb)
7372
{
7473
blurImg = info[5]->BooleanValue();
7574
}
76-
typedef std::pair<af::features, af::array> result_t;
77-
typedef Worker<result_t> worker_t;
78-
auto exec = [=]()
79-
{
80-
Guard guard;
81-
result_t result;
82-
af::orb(result.first, result.second, array, fastThr, maxFeat, sclFctr, levels, blurImg);
83-
return result;
84-
};
85-
auto conv = [=](worker_t* worker, const result_t& r)
86-
{
87-
Nan::EscapableHandleScope scope;
88-
auto result = Nan::New<Object>();
89-
result->Set(Nan::New(Symbols::Feat), ToV8Features(r.first));
90-
result->Set(Nan::New(Symbols::Desc), ArrayWrapper::New(r.second));
91-
return scope.Escape(result);
92-
};
93-
auto worker = new worker_t(GetCallback(info), std::move(exec), std::move(conv));
94-
Nan::AsyncQueueWorker(worker);
95-
info.GetReturnValue().SetUndefined();
75+
Guard guard;
76+
af::features rf;
77+
af::array ra;
78+
af::orb(rf, ra, *pArray, fastThr, maxFeat, sclFctr, levels, blurImg);
79+
auto result = Nan::New<Object>();
80+
result->Set(Nan::New(Symbols::Feat), ToV8Features(rf));
81+
result->Set(Nan::New(Symbols::Desc), ArrayWrapper::New(ra));
82+
info.GetReturnValue().Set(result);
9683
}
9784
ARRAYFIRE_CATCH
9885
}
@@ -102,8 +89,8 @@ NAN_METHOD(Fast)
10289

10390
try
10491
{
105-
ARGS_LEN(2);
106-
auto array = *ArrayWrapper::GetArrayAt(info, 0);
92+
ARGS_LEN(1);
93+
auto pArray = ArrayWrapper::GetArrayAt(info, 0);
10794
float thr=20.0f;
10895
unsigned arcLength=9;
10996
bool nonMax=true;
@@ -129,20 +116,10 @@ NAN_METHOD(Fast)
129116
{
130117
edge = info[5]->Uint32Value();
131118
}
132-
typedef Worker<af::features> worker_t;
133-
auto exec = [=]()
134-
{
135-
Guard guard;
136-
return af::fast(array, thr, arcLength, nonMax, featureRatio, edge);
137-
};
138-
auto conv = [=](worker_t* worker, const af::features& feat)
139-
{
140-
return ToV8Features(feat);
141-
};
142-
143-
auto worker = new worker_t(GetCallback(info), std::move(exec), std::move(conv));
144-
Nan::AsyncQueueWorker(worker);
145-
info.GetReturnValue().SetUndefined();
119+
Guard guard;
120+
af::features rf;
121+
af::fast(*pArray, thr, arcLength, nonMax, featureRatio, edge);
122+
info.GetReturnValue().Set(ToV8Features(rf));
146123
}
147124
ARRAYFIRE_CATCH
148125
}
@@ -152,9 +129,9 @@ NAN_METHOD(HammingMatcher)
152129

153130
try
154131
{
155-
ARGS_LEN(3);
156-
auto array1 = *ArrayWrapper::GetArrayAt(info, 0);
157-
auto array2 = *ArrayWrapper::GetArrayAt(info, 1);
132+
ARGS_LEN(2);
133+
auto pArray1 = ArrayWrapper::GetArrayAt(info, 0);
134+
auto pArray2 = ArrayWrapper::GetArrayAt(info, 1);
158135
dim_t distDim = 0;
159136
unsigned nDist = 1;
160137
if (info.Length() > 2)
@@ -165,26 +142,13 @@ NAN_METHOD(HammingMatcher)
165142
{
166143
nDist = info[3]->Uint32Value();
167144
}
168-
typedef std::pair<af::array, af::array> result_t;
169-
typedef Worker<result_t> worker_t;
170-
auto exec = [=]()
171-
{
172-
Guard guard;
173-
result_t result;
174-
af::hammingMatcher(result.first, result.second, array1, array2, distDim, nDist);
175-
return result;
176-
};
177-
auto conv = [=](worker_t* worker, const result_t& r)
178-
{
179-
Nan::EscapableHandleScope scope;
180-
auto result = Nan::New<Object>();
181-
result->Set(Nan::New(Symbols::Idx), ArrayWrapper::New(r.first));
182-
result->Set(Nan::New(Symbols::Dist), ArrayWrapper::New(r.second));
183-
return scope.Escape(result);
184-
};
185-
auto worker = new worker_t(GetCallback(info), std::move(exec), std::move(conv));
186-
Nan::AsyncQueueWorker(worker);
187-
info.GetReturnValue().SetUndefined();
145+
Guard guard;
146+
std::pair<af::array, af::array> r;
147+
af::hammingMatcher(r.first, r.second, *pArray1, *pArray2, distDim, nDist);
148+
auto result = Nan::New<Object>();
149+
result->Set(Nan::New(Symbols::Idx), ArrayWrapper::New(r.first));
150+
result->Set(Nan::New(Symbols::Dist), ArrayWrapper::New(r.second));
151+
info.GetReturnValue().Set(result);
188152
}
189153
ARRAYFIRE_CATCH
190154
}
@@ -194,28 +158,16 @@ NAN_METHOD(MatchTemplate)
194158

195159
try
196160
{
197-
ARGS_LEN(3);
198-
auto array1 = *ArrayWrapper::GetArrayAt(info, 0);
199-
auto array2 = *ArrayWrapper::GetArrayAt(info, 1);
161+
ARGS_LEN(2);
162+
auto pArray1 = ArrayWrapper::GetArrayAt(info, 0);
163+
auto pArray2 = ArrayWrapper::GetArrayAt(info, 1);
200164
af::matchType mType = AF_SAD;
201165
if (info.Length() > 2)
202166
{
203167
mType = (af::matchType)(info[2]->Uint32Value());
204168
}
205-
typedef Worker<af::array> worker_t;
206-
auto exec = [=]()
207-
{
208-
Guard guard;
209-
return af::matchTemplate(array1, array2, mType);
210-
};
211-
auto conv = [=](worker_t* worker, const af::array& arr)
212-
{
213-
return ArrayWrapper::New(arr);
214-
};
215-
216-
auto worker = new worker_t(GetCallback(info), std::move(exec), std::move(conv));
217-
Nan::AsyncQueueWorker(worker);
218-
info.GetReturnValue().SetUndefined();
169+
Guard guard;
170+
info.GetReturnValue().Set(ArrayWrapper::New(af::matchTemplate(*pArray1, *pArray2, mType)));
219171
}
220172
ARRAYFIRE_CATCH
221173
}

‎src/createarray.cpp

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -231,8 +231,8 @@ NAN_METHOD(Constant)
231231
ARRAYFIRE_CATCH
232232
}
233233

234-
AF_SM_ARR_BOOL(Lower, lower, false)
235-
AF_SM_ARR_BOOL(Upper, upper, false)
234+
AF_ARR_BOOL(Lower, lower, false)
235+
AF_ARR_BOOL(Upper, upper, false)
236236

237237
NAN_METHOD(GetSeed)
238238
{
@@ -270,7 +270,7 @@ NAN_METHOD(SetSeed)
270270
ARRAYFIRE_CATCH;
271271
}
272272

273-
AF_SM_ARR_ARR_DIM(Lookup, lookup)
273+
AF_ARR_ARR_DIM(Lookup, lookup)
274274

275275
NAN_MODULE_INIT(InitCreateArray)
276276
{

0 commit comments

Comments
 (0)